diff --git a/Tools/build/.ruff.toml b/Tools/build/.ruff.toml
new file mode 100644
index 0000000..dcbf293
--- /dev/null
+++ b/Tools/build/.ruff.toml
@@ -0,0 +1,41 @@
+extend = "../../.ruff.toml"  # Inherit the project-wide settings
+
+[per-file-target-version]
+"deepfreeze.py" = "py311"  # requires `code.co_exceptiontable`
+"stable_abi.py" = "py311"  # requires 'tomllib'
+
+[format]
+preview = true
+docstring-code-format = true
+
+[lint]
+select = [
+    "C4",      # flake8-comprehensions
+    "E",       # pycodestyle
+    "F",       # pyflakes
+    "I",       # isort
+    "ISC",     # flake8-implicit-str-concat
+    "LOG",     # flake8-logging
+    "PGH",     # pygrep-hooks
+    "PT",      # flake8-pytest-style
+    "PYI",     # flake8-pyi
+    "RUF100",  # Ban unused `# noqa` comments
+    "UP",      # pyupgrade
+    "W",       # pycodestyle
+    "YTT",     # flake8-2020
+]
+ignore = [
+    "E501",    # Line too long
+    "F541",    # f-string without any placeholders
+    "PYI024",  # Use `typing.NamedTuple` instead of `collections.namedtuple`
+    "PYI025",  # Use `from collections.abc import Set as AbstractSet`
+    "UP038",   # Use `X | Y` in `isinstance` call instead of `(X, Y)`
+]
+
+[lint.per-file-ignores]
+"{check_extension_modules,freeze_modules}.py" = [
+    "UP031",  # Use format specifiers instead of percent format
+]
+"generate_{re_casefix,sre_constants,token}.py" = [
+    "UP031",  # Use format specifiers instead of percent format
+]
diff --git a/Tools/build/.warningignore_macos b/Tools/build/.warningignore_macos
new file mode 100644
index 0000000..d7b62bc
--- /dev/null
+++ b/Tools/build/.warningignore_macos
@@ -0,0 +1,9 @@
+# Files listed will be ignored by the compiler warning checker
+# for the macOS/build and test job.
+# Keep lines sorted lexicographically to help avoid merge conflicts.
+# Format example:
+# /path/to/file (number of warnings in file)
+Modules/expat/siphash.h 7
+Modules/expat/xmlparse.c 13
+Modules/expat/xmltok.c 3
+Modules/expat/xmltok_impl.c 26
diff --git a/Tools/build/.warningignore_ubuntu b/Tools/build/.warningignore_ubuntu
new file mode 100644
index 0000000..469c727
--- /dev/null
+++ b/Tools/build/.warningignore_ubuntu
@@ -0,0 +1,5 @@
+# Files listed will be ignored by the compiler warning checker
+# for the Ubuntu/build and test job.
+# Keep lines sorted lexicographically to help avoid merge conflicts.
+# Format example:
+# /path/to/file (number of warnings in file)
diff --git a/Tools/build/check_extension_modules.py b/Tools/build/check_extension_modules.py
index e0c7a92..668db8d 100644
--- a/Tools/build/check_extension_modules.py
+++ b/Tools/build/check_extension_modules.py
@@ -30,10 +30,15 @@
 import sys
 import sysconfig
 import warnings
-
 from collections.abc import Iterable
-from importlib._bootstrap import _load as bootstrap_load  # type: ignore[attr-defined]
-from importlib.machinery import BuiltinImporter, ExtensionFileLoader, ModuleSpec
+from importlib._bootstrap import (  # type: ignore[attr-defined]
+    _load as bootstrap_load,
+)
+from importlib.machinery import (
+    BuiltinImporter,
+    ExtensionFileLoader,
+    ModuleSpec,
+)
 from importlib.util import spec_from_file_location, spec_from_loader
 from typing import NamedTuple
 
@@ -201,7 +206,7 @@ def print_three_column(modinfos: list[ModuleInfo]) -> None:
             # guarantee zip() doesn't drop anything
             while len(names) % 3:
                 names.append("")
-            for l, m, r in zip(names[::3], names[1::3], names[2::3]):
+            for l, m, r in zip(names[::3], names[1::3], names[2::3]):  # noqa: E741
                 print("%-*s   %-*s   %-*s" % (longest, l, longest, m, longest, r))
 
         if verbose and self.builtin_ok:
@@ -433,7 +438,7 @@ def check_module_import(self, modinfo: ModuleInfo) -> None:
         except ImportError as e:
             logger.error("%s failed to import: %s", modinfo.name, e)
             raise
-        except Exception as e:
+        except Exception:
             if not hasattr(_imp, 'create_dynamic'):
                 logger.warning("Dynamic extension '%s' ignored", modinfo.name)
                 return
diff --git a/Tools/build/check_warnings.py b/Tools/build/check_warnings.py
new file mode 100644
index 0000000..3f49d8e
--- /dev/null
+++ b/Tools/build/check_warnings.py
@@ -0,0 +1,316 @@
+"""
+Parses compiler output from Clang or GCC and checks that warnings
+exist only in files that are expected to have warnings.
+"""
+
+import argparse
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import NamedTuple
+
+
+class IgnoreRule(NamedTuple):
+    file_path: str
+    count: int
+    ignore_all: bool = False
+    is_directory: bool = False
+
+
+def parse_warning_ignore_file(file_path: str) -> set[IgnoreRule]:
+    """
+    Parses the warning ignore file and returns a set of IgnoreRules
+    """
+    files_with_expected_warnings = set()
+    with Path(file_path).open(encoding="UTF-8") as ignore_rules_file:
+        files_with_expected_warnings = set()
+        for i, line in enumerate(ignore_rules_file):
+            line = line.strip()
+            if line and not line.startswith("#"):
+                line_parts = line.split()
+                if len(line_parts) >= 2:
+                    file_name = line_parts[0]
+                    count = line_parts[1]
+                    ignore_all = count == "*"
+                    is_directory = file_name.endswith("/")
+
+                    # Directories must have a wildcard count
+                    if is_directory and count != "*":
+                        print(
+                            f"Error parsing ignore file: {file_path} "
+                            f"at line: {i}"
+                        )
+                        print(
+                            f"Directory {file_name} must have count set to *"
+                        )
+                        sys.exit(1)
+                    if ignore_all:
+                        count = 0
+
+                    files_with_expected_warnings.add(
+                        IgnoreRule(
+                            file_name, int(count), ignore_all, is_directory
+                        )
+                    )
+
+    return files_with_expected_warnings
+
+
+def extract_warnings_from_compiler_output(
+    compiler_output: str,
+    compiler_output_type: str,
+    path_prefix: str = "",
+) -> list[dict]:
+    """
+    Extracts warnings from the compiler output based on compiler
+    output type. Removes path prefix from file paths if provided.
+    Compatible with GCC and Clang compiler output.
+    """
+    # Choose pattern and compile regex for particular compiler output
+    if compiler_output_type == "gcc":
+        regex_pattern = (
+            r"(?P<file>.*):(?P<line>\d+):(?P<column>\d+): warning: "
+            r"(?P<message>.*?)(?: (?P<option>\[-[^\]]+\]))?$"
+        )
+    elif compiler_output_type == "clang":
+        regex_pattern = (
+            r"(?P<file>.*):(?P<line>\d+):(?P<column>\d+): warning: "
+            r"(?P<message>.*) (?P<option>\[-[^\]]+\])$"
+        )
+    compiled_regex = re.compile(regex_pattern)
+    compiler_warnings = []
+    for i, line in enumerate(compiler_output.splitlines(), start=1):
+        if match := compiled_regex.match(line):
+            try:
+                compiler_warnings.append({
+                    "file": match.group("file").removeprefix(path_prefix),
+                    "line": match.group("line"),
+                    "column": match.group("column"),
+                    "message": match.group("message"),
+                    "option": match.group("option").lstrip("[").rstrip("]"),
+                })
+            except AttributeError:
+                print(
+                    f"Error parsing compiler output. "
+                    f"Unable to extract warning on line {i}:\n{line}"
+                )
+                sys.exit(1)
+
+    return compiler_warnings
+
+
+def get_warnings_by_file(warnings: list[dict]) -> dict[str, list[dict]]:
+    """
+    Returns a dictionary where the key is the file and the data is the
+    warnings in that file. Does not include duplicate warnings for a
+    file from list of provided warnings.
+    """
+    warnings_by_file = defaultdict(list)
+    warnings_added = set()
+    for warning in warnings:
+        warning_key = (
+            f"{warning['file']}-{warning['line']}-"
+            f"{warning['column']}-{warning['option']}"
+        )
+        if warning_key not in warnings_added:
+            warnings_added.add(warning_key)
+            warnings_by_file[warning["file"]].append(warning)
+
+    return warnings_by_file
+
+
+def is_file_ignored(
+    file_path: str, ignore_rules: set[IgnoreRule]
+) -> IgnoreRule | None:
+    """Return the IgnoreRule object for the file path.
+
+    Return ``None`` if there is no related rule for that path.
+    """
+    for rule in ignore_rules:
+        if rule.is_directory:
+            if file_path.startswith(rule.file_path):
+                return rule
+        elif file_path == rule.file_path:
+            return rule
+    return None
+
+
+def get_unexpected_warnings(
+    ignore_rules: set[IgnoreRule],
+    files_with_warnings: set[IgnoreRule],
+) -> int:
+    """
+    Returns failure status if warnings discovered in list of warnings
+    are associated with a file that is not found in the list of files
+    with expected warnings
+    """
+    unexpected_warnings = {}
+    for file in files_with_warnings.keys():
+        rule = is_file_ignored(file, ignore_rules)
+
+        if rule:
+            if rule.ignore_all:
+                continue
+
+            if len(files_with_warnings[file]) > rule.count:
+                unexpected_warnings[file] = (
+                    files_with_warnings[file],
+                    rule.count,
+                )
+            continue
+        elif rule is None:
+            # If the file is not in the ignore list, then it is unexpected
+            unexpected_warnings[file] = (files_with_warnings[file], 0)
+
+    if unexpected_warnings:
+        print("Unexpected warnings:")
+        for file in unexpected_warnings:
+            print(
+                f"{file} expected {unexpected_warnings[file][1]} warnings,"
+                f" found {len(unexpected_warnings[file][0])}"
+            )
+            for warning in unexpected_warnings[file][0]:
+                print(warning)
+
+        return 1
+
+    return 0
+
+
+def get_unexpected_improvements(
+    ignore_rules: set[IgnoreRule],
+    files_with_warnings: set[IgnoreRule],
+) -> int:
+    """
+    Returns failure status if the number of warnings for a file is greater
+    than the expected number of warnings for that file based on the ignore
+    rules
+    """
+    unexpected_improvements = []
+    for rule in ignore_rules:
+        if (
+            not rule.ignore_all
+            and rule.file_path not in files_with_warnings.keys()
+        ):
+            if rule.file_path not in files_with_warnings.keys():
+                unexpected_improvements.append((rule.file_path, rule.count, 0))
+            elif len(files_with_warnings[rule.file_path]) < rule.count:
+                unexpected_improvements.append((
+                    rule.file_path,
+                    rule.count,
+                    len(files_with_warnings[rule.file_path]),
+                ))
+
+    if unexpected_improvements:
+        print("Unexpected improvements:")
+        for file in unexpected_improvements:
+            print(f"{file[0]} expected {file[1]} warnings, found {file[2]}")
+        return 1
+
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c",
+        "--compiler-output-file-path",
+        type=str,
+        required=True,
+        help="Path to the compiler output file",
+    )
+    parser.add_argument(
+        "-i",
+        "--warning-ignore-file-path",
+        type=str,
+        help="Path to the warning ignore file",
+    )
+    parser.add_argument(
+        "-x",
+        "--fail-on-regression",
+        action="store_true",
+        default=False,
+        help="Flag to fail if new warnings are found",
+    )
+    parser.add_argument(
+        "-X",
+        "--fail-on-improvement",
+        action="store_true",
+        default=False,
+        help="Flag to fail if files that were expected "
+        "to have warnings have no warnings",
+    )
+    parser.add_argument(
+        "-t",
+        "--compiler-output-type",
+        type=str,
+        required=True,
+        choices=["gcc", "clang"],
+        help="Type of compiler output file (GCC or Clang)",
+    )
+    parser.add_argument(
+        "-p",
+        "--path-prefix",
+        type=str,
+        help="Path prefix to remove from the start of file paths"
+        " in compiler output",
+    )
+
+    args = parser.parse_args(argv)
+
+    exit_code = 0
+
+    # Check that the compiler output file is a valid path
+    if not Path(args.compiler_output_file_path).is_file():
+        print(
+            f"Compiler output file does not exist:"
+            f" {args.compiler_output_file_path}"
+        )
+        return 1
+
+    # Check that a warning ignore file was specified and if so is a valid path
+    if not args.warning_ignore_file_path:
+        print(
+            "Warning ignore file not specified."
+            " Continuing without it (no warnings ignored)."
+        )
+        ignore_rules = set()
+    else:
+        if not Path(args.warning_ignore_file_path).is_file():
+            print(
+                f"Warning ignore file does not exist:"
+                f" {args.warning_ignore_file_path}"
+            )
+            return 1
+        ignore_rules = parse_warning_ignore_file(args.warning_ignore_file_path)
+
+    with Path(args.compiler_output_file_path).open(encoding="UTF-8") as f:
+        compiler_output_file_contents = f.read()
+
+    warnings = extract_warnings_from_compiler_output(
+        compiler_output_file_contents,
+        args.compiler_output_type,
+        args.path_prefix,
+    )
+
+    files_with_warnings = get_warnings_by_file(warnings)
+
+    status = get_unexpected_warnings(ignore_rules, files_with_warnings)
+    if args.fail_on_regression:
+        exit_code |= status
+
+    status = get_unexpected_improvements(ignore_rules, files_with_warnings)
+    if args.fail_on_improvement:
+        exit_code |= status
+
+    print(
+        "For information about this tool and its configuration"
+        " visit https://devguide.python.org/development-tools/warnings/"
+    )
+
+    return exit_code
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/Tools/build/deepfreeze.py b/Tools/build/deepfreeze.py
index 35decd9..2b9f03a 100644
--- a/Tools/build/deepfreeze.py
+++ b/Tools/build/deepfreeze.py
@@ -16,19 +16,20 @@
 import re
 import time
 import types
+
 import umarshal
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
     from collections.abc import Iterator
-    from typing import Any, TextIO, Dict, FrozenSet, TextIO, Tuple
+    from typing import Any, TextIO
 
 ROOT = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 
 verbose = False
 
 # This must be kept in sync with Tools/cases_generator/analyzer.py
-RESUME = 149
+RESUME = 128
 
 def isprintable(b: bytes) -> bool:
     return all(0x20 <= c < 0x7f for c in b)
@@ -63,8 +64,8 @@ def get_localsplus(code: types.CodeType) -> tuple[tuple[str, ...], bytes]:
 
 
 def get_localsplus_counts(code: types.CodeType,
-                          names: Tuple[str, ...],
-                          kinds: bytes) -> Tuple[int, int, int]:
+                          names: tuple[str, ...],
+                          kinds: bytes) -> tuple[int, int, int]:
     nlocals = 0
     ncellvars = 0
     nfreevars = 0
@@ -90,7 +91,7 @@ def get_localsplus_counts(code: types.CodeType,
 PyUnicode_4BYTE_KIND = 4
 
 
-def analyze_character_width(s: str) -> Tuple[int, bool]:
+def analyze_character_width(s: str) -> tuple[int, bool]:
     maxchar = ' '
     for c in s:
         maxchar = max(maxchar, c)
@@ -115,7 +116,7 @@ class Printer:
     def __init__(self, file: TextIO) -> None:
         self.level = 0
         self.file = file
-        self.cache: Dict[tuple[type, object, str], str] = {}
+        self.cache: dict[tuple[type, object, str], str] = {}
         self.hits, self.misses = 0, 0
         self.finis: list[str] = []
         self.inits: list[str] = []
@@ -319,7 +320,7 @@ def generate_code(self, name: str, code: types.CodeType) -> str:
         self.inits.append(f"_PyStaticCode_Init({name_as_code})")
         return f"& {name}.ob_base.ob_base"
 
-    def generate_tuple(self, name: str, t: Tuple[object, ...]) -> str:
+    def generate_tuple(self, name: str, t: tuple[object, ...]) -> str:
         if len(t) == 0:
             return f"(PyObject *)& _Py_SINGLETON(tuple_empty)"
         items = [self.generate(f"{name}_{i}", it) for i, it in enumerate(t)]
@@ -393,7 +394,7 @@ def generate_complex(self, name: str, z: complex) -> str:
             self.write(f".cval = {{ {z.real}, {z.imag} }},")
         return f"&{name}.ob_base"
 
-    def generate_frozenset(self, name: str, fs: FrozenSet[Any]) -> str:
+    def generate_frozenset(self, name: str, fs: frozenset[Any]) -> str:
         try:
             fs_sorted = sorted(fs)
         except TypeError:
@@ -479,7 +480,7 @@ def generate(args: list[str], output: TextIO) -> None:
     printer = Printer(output)
     for arg in args:
         file, modname = arg.rsplit(':', 1)
-        with open(file, "r", encoding="utf8") as fd:
+        with open(file, encoding="utf8") as fd:
             source = fd.read()
             if is_frozen_header(source):
                 code = decode_frozen_data(source)
@@ -527,7 +528,7 @@ def main() -> None:
     if args.file:
         if verbose:
             print(f"Reading targets from {args.file}")
-        with open(args.file, "rt", encoding="utf-8-sig") as fin:
+        with open(args.file, encoding="utf-8-sig") as fin:
             rules = [x.strip() for x in fin]
     else:
         rules = args.args
diff --git a/Tools/build/freeze_modules.py b/Tools/build/freeze_modules.py
index eef2d0a..3c43f7e 100644
--- a/Tools/build/freeze_modules.py
+++ b/Tools/build/freeze_modules.py
@@ -3,14 +3,13 @@
 See the notes at the top of Python/frozen.c for more info.
 """
 
-from collections import namedtuple
 import hashlib
-import os
 import ntpath
+import os
 import posixpath
-import argparse
-from update_file import updating_file_with_tmpfile
+from collections import namedtuple
 
+from update_file import updating_file_with_tmpfile
 
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 ROOT_DIR = os.path.abspath(ROOT_DIR)
@@ -63,9 +62,6 @@
         'genericpath',
         'ntpath',
         'posixpath',
-        # We must explicitly mark os.path as a frozen module
-        # even though it will never be imported.
-        f'{OS_PATH} : os.path',
         'os',
         'site',
         'stat',
@@ -485,7 +481,6 @@ def regen_frozen(modules):
         header = relpath_for_posix_display(src.frozenfile, parentdir)
         headerlines.append(f'#include "{header}"')
 
-    externlines = UniqueList()
     bootstraplines = []
     stdliblines = []
     testlines = []
@@ -628,7 +623,6 @@ def regen_makefile(modules):
 def regen_pcbuild(modules):
     projlines = []
     filterlines = []
-    corelines = []
     for src in _iter_sources(modules):
         pyfile = relpath_for_windows_display(src.pyfile, ROOT_DIR)
         header = relpath_for_windows_display(src.frozenfile, ROOT_DIR)
diff --git a/Tools/build/generate-build-details.py b/Tools/build/generate-build-details.py
new file mode 100644
index 0000000..8cd23e2
--- /dev/null
+++ b/Tools/build/generate-build-details.py
@@ -0,0 +1,194 @@
+"""Generate build-details.json (see PEP 739)."""
+
+# Script initially imported from:
+# https://github.com/FFY00/python-instrospection/blob/main/python_introspection/scripts/generate-build-details.py
+
+from __future__ import annotations
+
+import argparse
+import collections
+import importlib.machinery
+import json
+import os
+import sys
+import sysconfig
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Any
+
+
+def version_info_to_dict(obj: sys._version_info) -> dict[str, Any]:
+    field_names = ('major', 'minor', 'micro', 'releaselevel', 'serial')
+    return {field: getattr(obj, field) for field in field_names}
+
+
+def get_dict_key(container: dict[str, Any], key: str) -> dict[str, Any]:
+    for part in key.split('.'):
+        container = container[part]
+    return container
+
+
+def generate_data(schema_version: str) -> collections.defaultdict[str, Any]:
+    """Generate the build-details.json data (PEP 739).
+
+    :param schema_version: The schema version of the data we want to generate.
+    """
+
+    if schema_version != '1.0':
+        raise ValueError(f'Unsupported schema_version: {schema_version}')
+
+    data: collections.defaultdict[str, Any] = collections.defaultdict(
+        lambda: collections.defaultdict(dict),
+    )
+
+    data['schema_version'] = schema_version
+
+    data['base_prefix'] = sysconfig.get_config_var('installed_base')
+    #data['base_interpreter'] = sys._base_executable
+    data['base_interpreter'] = os.path.join(
+        sysconfig.get_path('scripts'),
+        'python' + sysconfig.get_config_var('VERSION'),
+    )
+    data['platform'] = sysconfig.get_platform()
+
+    data['language']['version'] = sysconfig.get_python_version()
+    data['language']['version_info'] = version_info_to_dict(sys.version_info)
+
+    data['implementation'] = vars(sys.implementation)
+    data['implementation']['version'] = version_info_to_dict(sys.implementation.version)
+    # Fix cross-compilation
+    if '_multiarch' in data['implementation']:
+        data['implementation']['_multiarch'] = sysconfig.get_config_var('MULTIARCH')
+
+    data['abi']['flags'] = list(sys.abiflags)
+
+    data['suffixes']['source'] = importlib.machinery.SOURCE_SUFFIXES
+    data['suffixes']['bytecode'] = importlib.machinery.BYTECODE_SUFFIXES
+    #data['suffixes']['optimized_bytecode'] = importlib.machinery.OPTIMIZED_BYTECODE_SUFFIXES
+    #data['suffixes']['debug_bytecode'] = importlib.machinery.DEBUG_BYTECODE_SUFFIXES
+    data['suffixes']['extensions'] = importlib.machinery.EXTENSION_SUFFIXES
+
+    LIBDIR = sysconfig.get_config_var('LIBDIR')
+    LDLIBRARY = sysconfig.get_config_var('LDLIBRARY')
+    LIBRARY = sysconfig.get_config_var('LIBRARY')
+    PY3LIBRARY = sysconfig.get_config_var('PY3LIBRARY')
+    LIBPYTHON = sysconfig.get_config_var('LIBPYTHON')
+    LIBPC = sysconfig.get_config_var('LIBPC')
+    INCLUDEPY = sysconfig.get_config_var('INCLUDEPY')
+
+    if os.name == 'posix':
+        # On POSIX, LIBRARY is always the static library, while LDLIBRARY is the
+        # dynamic library if enabled, otherwise it's the static library.
+        # If LIBRARY != LDLIBRARY, support for the dynamic library is enabled.
+        has_dynamic_library = LDLIBRARY != LIBRARY
+        has_static_library = sysconfig.get_config_var('STATIC_LIBPYTHON')
+    elif os.name == 'nt':
+        # Windows can only use a dynamic library or a static library.
+        # If it's using a dynamic library, sys.dllhandle will be set.
+        # Static builds on Windows are not really well supported, though.
+        # More context: https://github.com/python/cpython/issues/110234
+        has_dynamic_library = hasattr(sys, 'dllhandle')
+        has_static_library = not has_dynamic_library
+    else:
+        raise NotADirectoryError(f'Unknown platform: {os.name}')
+
+    # On POSIX, EXT_SUFFIX is set regardless if extension modules are supported
+    # or not, and on Windows older versions of CPython only set EXT_SUFFIX when
+    # extension modules are supported, but newer versions of CPython set it
+    # regardless.
+    #
+    # We only want to set abi.extension_suffix and stable_abi_suffix if
+    # extension modules are supported.
+    if has_dynamic_library:
+        data['abi']['extension_suffix'] = sysconfig.get_config_var('EXT_SUFFIX')
+
+        # EXTENSION_SUFFIXES has been constant for a long time, and currently we
+        # don't have a better information source to find the  stable ABI suffix.
+        for suffix in importlib.machinery.EXTENSION_SUFFIXES:
+            if suffix.startswith('.abi'):
+                data['abi']['stable_abi_suffix'] = suffix
+                break
+
+        data['libpython']['dynamic'] = os.path.join(LIBDIR, LDLIBRARY)
+        # FIXME: Not sure if windows has a different dll for the stable ABI, and
+        #        even if it does, currently we don't have a way to get its name.
+        if PY3LIBRARY:
+            data['libpython']['dynamic_stableabi'] = os.path.join(LIBDIR, PY3LIBRARY)
+
+        # Os POSIX, this is defined by the LIBPYTHON Makefile variable not being
+        # empty. On Windows, don't link extensions — LIBPYTHON won't be defined,
+        data['libpython']['link_extensions'] = bool(LIBPYTHON)
+
+    if has_static_library:
+        data['libpython']['static'] = os.path.join(LIBDIR, LIBRARY)
+
+    data['c_api']['headers'] = INCLUDEPY
+    if LIBPC:
+        data['c_api']['pkgconfig_path'] = LIBPC
+
+    return data
+
+
+def make_paths_relative(data: dict[str, Any], config_path: str | None = None) -> None:
+    # Make base_prefix relative to the config_path directory
+    if config_path:
+        data['base_prefix'] = os.path.relpath(data['base_prefix'], os.path.dirname(config_path))
+    # Update path values to make them relative to base_prefix
+    PATH_KEYS = [
+        'base_interpreter',
+        'libpython.dynamic',
+        'libpython.dynamic_stableabi',
+        'libpython.static',
+        'c_api.headers',
+        'c_api.pkgconfig_path',
+    ]
+    for entry in PATH_KEYS:
+        parent, _, child = entry.rpartition('.')
+        # Get the key container object
+        try:
+            container = data
+            for part in parent.split('.'):
+                container = container[part]
+            current_path = container[child]
+        except KeyError:
+            continue
+        # Get the relative path
+        new_path = os.path.relpath(current_path, data['base_prefix'])
+        # Join '.' so that the path is formated as './path' instead of 'path'
+        new_path = os.path.join('.', new_path)
+        container[child] = new_path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(exit_on_error=False)
+    parser.add_argument('location')
+    parser.add_argument(
+        '--schema-version',
+        default='1.0',
+        help='Schema version of the build-details.json file to generate.',
+    )
+    parser.add_argument(
+        '--relative-paths',
+        action='store_true',
+        help='Whether to specify paths as absolute, or as relative paths to ``base_prefix``.',
+    )
+    parser.add_argument(
+        '--config-file-path',
+        default=None,
+        help='If specified, ``base_prefix`` will be set as a relative path to the given config file path.',
+    )
+
+    args = parser.parse_args()
+
+    data = generate_data(args.schema_version)
+    if args.relative_paths:
+        make_paths_relative(data, args.config_file_path)
+
+    json_output = json.dumps(data, indent=2)
+    with open(args.location, 'w') as f:
+        print(json_output, file=f)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/Tools/build/generate_global_objects.py b/Tools/build/generate_global_objects.py
index 882918f..94905b3 100644
--- a/Tools/build/generate_global_objects.py
+++ b/Tools/build/generate_global_objects.py
@@ -277,7 +277,7 @@ def generate_runtime_init(identifiers, strings):
     # First get some info from the declarations.
     nsmallposints = None
     nsmallnegints = None
-    with open(os.path.join(INTERNAL, 'pycore_global_objects.h')) as infile:
+    with open(os.path.join(INTERNAL, 'pycore_runtime_structs.h')) as infile:
         for line in infile:
             if line.startswith('#define _PY_NSMALLPOSINTS'):
                 nsmallposints = int(line.split()[-1])
@@ -286,7 +286,8 @@ def generate_runtime_init(identifiers, strings):
                 break
         else:
             raise NotImplementedError
-    assert nsmallposints and nsmallnegints
+    assert nsmallposints
+    assert nsmallnegints
 
     # Then target the runtime initializer.
     filename = os.path.join(INTERNAL, 'pycore_runtime_init_generated.h')
@@ -433,16 +434,16 @@ def get_identifiers_and_strings() -> 'tuple[set[str], dict[str, str]]':
                 # Give a nice message for common mistakes.
                 # To cover tricky cases (like "\n") we also generate C asserts.
                 raise ValueError(
-                    'do not use &_PyID or &_Py_STR for one-character latin-1 '
-                    + f'strings, use _Py_LATIN1_CHR instead: {string!r}')
+                    'do not use &_Py_ID or &_Py_STR for one-character latin-1 '
+                    f'strings, use _Py_LATIN1_CHR instead: {string!r}')
             if string not in strings:
                 strings[string] = name
             elif name != strings[string]:
-                raise ValueError(f'string mismatch for {name!r} ({string!r} != {strings[name]!r}')
+                raise ValueError(f'name mismatch for string {string!r} ({name!r} != {strings[string]!r}')
     overlap = identifiers & set(strings.keys())
     if overlap:
         raise ValueError(
-            'do not use both _PyID and _Py_DECLARE_STR for the same string: '
+            'do not use both _Py_ID and _Py_DECLARE_STR for the same string: '
             + repr(overlap))
     return identifiers, strings
 
diff --git a/Tools/build/generate_levenshtein_examples.py b/Tools/build/generate_levenshtein_examples.py
index 778eb45..30dcc7c 100644
--- a/Tools/build/generate_levenshtein_examples.py
+++ b/Tools/build/generate_levenshtein_examples.py
@@ -1,12 +1,11 @@
 """Generate 10,000 unique examples for the Levenshtein short-circuit tests."""
 
 import argparse
-from functools import lru_cache
 import json
 import os.path
+from functools import lru_cache
 from random import choices, randrange
 
-
 # This should be in sync with Lib/traceback.py.  It's not importing those values
 # because this script is being executed by PYTHON_FOR_REGEN and not by the in-tree
 # build of Python.
diff --git a/Tools/build/generate_re_casefix.py b/Tools/build/generate_re_casefix.py
index 6cebfbd..9345b8f 100644
--- a/Tools/build/generate_re_casefix.py
+++ b/Tools/build/generate_re_casefix.py
@@ -9,7 +9,7 @@
 
 def update_file(file, content):
     try:
-        with open(file, 'r', encoding='utf-8') as fobj:
+        with open(file, encoding='utf-8') as fobj:
             if fobj.read() == content:
                 return False
     except (OSError, ValueError):
@@ -50,7 +50,7 @@ def main(outfile='Lib/re/_casefix.py'):
     # List of codes of lowercased characters which have the same uppercase.
     equivalent_lower_codes = [sorted(t)
                               for s in equivalent_chars
-                              for t in [set(ord(c.lower()) for c in s)]
+                              for t in [{ord(c.lower()) for c in s}]
                               if len(t) > 1]
 
     bad_codes = []
diff --git a/Tools/build/generate_sbom.py b/Tools/build/generate_sbom.py
index 82f06f0..9683977 100644
--- a/Tools/build/generate_sbom.py
+++ b/Tools/build/generate_sbom.py
@@ -1,18 +1,18 @@
 """Tool for generating Software Bill of Materials (SBOM) for Python's dependencies"""
+
+import glob
+import hashlib
+import json
 import os
 import random
 import re
-import hashlib
-import json
-import glob
-from pathlib import Path, PurePosixPath, PureWindowsPath
 import subprocess
 import sys
 import time
 import typing
 import urllib.error
 import urllib.request
-import typing
+from pathlib import Path, PurePosixPath, PureWindowsPath
 
 CPYTHON_ROOT_DIR = Path(__file__).parent.parent.parent
 
@@ -64,7 +64,7 @@ class PackageFiles(typing.NamedTuple):
         exclude=[
             "Modules/expat/expat_config.h",
             "Modules/expat/pyexpatns.h",
-            "Modules/_hacl/refresh.sh",
+            "Modules/expat/refresh.sh",
         ]
     ),
     "macholib": PackageFiles(
@@ -75,9 +75,6 @@ class PackageFiles(typing.NamedTuple):
             "Lib/ctypes/macholib/fetch_macholib.bat",
         ],
     ),
-    "libb2": PackageFiles(
-        include=["Modules/_blake2/impl/**"]
-    ),
     "hacl-star": PackageFiles(
         include=["Modules/_hacl/**"],
         exclude=[
@@ -172,10 +169,10 @@ def download_with_retries(download_location: str,
                           base_delay: float = 2.25,
                           max_jitter: float = 1.0) -> typing.Any:
     """Download a file with exponential backoff retry."""
-    for attempt in range(max_retries):
+    for attempt in range(max_retries + 1):
         try:
             resp = urllib.request.urlopen(download_location)
-        except urllib.error.URLError as ex:
+        except (urllib.error.URLError, ConnectionError) as ex:
             if attempt == max_retries:
                 msg = f"Download from {download_location} failed."
                 raise OSError(msg) from ex
@@ -274,7 +271,7 @@ def check_sbom_packages(sbom_data: dict[str, typing.Any]) -> None:
         license_concluded = package["licenseConcluded"]
         error_if(
             license_concluded != "NOASSERTION",
-            f"License identifier must be 'NOASSERTION'"
+            "License identifier must be 'NOASSERTION'"
         )
 
 
diff --git a/Tools/build/generate_sre_constants.py b/Tools/build/generate_sre_constants.py
index abea069..f51339d 100644
--- a/Tools/build/generate_sre_constants.py
+++ b/Tools/build/generate_sre_constants.py
@@ -6,7 +6,7 @@
 
 def update_file(file, content):
     try:
-        with open(file, 'r') as fobj:
+        with open(file) as fobj:
             if fobj.read() == content:
                 return False
     except (OSError, ValueError):
diff --git a/Tools/build/generate_stdlib_module_names.py b/Tools/build/generate_stdlib_module_names.py
index 93a9fbe..bda7253 100644
--- a/Tools/build/generate_stdlib_module_names.py
+++ b/Tools/build/generate_stdlib_module_names.py
@@ -10,7 +10,6 @@
 
 from check_extension_modules import ModuleChecker
 
-
 SCRIPT_NAME = 'Tools/build/generate_stdlib_module_names.py'
 
 SRC_DIR = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
@@ -38,7 +37,6 @@
     '_testlimitedcapi',
     '_testmultiphase',
     '_testsinglephase',
-    '_testexternalinspection',
     '_xxtestfuzz',
     'idlelib.idle_test',
     'test',
diff --git a/Tools/build/generate_token.py b/Tools/build/generate_token.py
index a5f9828..9ee5ec8 100644
--- a/Tools/build/generate_token.py
+++ b/Tools/build/generate_token.py
@@ -13,7 +13,6 @@
 
 import re
 
-
 SCRIPT_NAME = 'Tools/build/generate_token.py'
 AUTO_GENERATED_BY_SCRIPT = f'Auto-generated by {SCRIPT_NAME}'
 NT_OFFSET = 256
@@ -46,7 +45,7 @@ def load_tokens(path):
 
 def update_file(file, content):
     try:
-        with open(file, 'r') as fobj:
+        with open(file) as fobj:
             if fobj.read() == content:
                 return False
     except (OSError, ValueError):
@@ -88,7 +87,8 @@ def update_file(file, content):
                                  (x) == INDENT    || \\
                                  (x) == DEDENT)
 #define ISSTRINGLIT(x)          ((x) == STRING           || \\
-                                 (x) == FSTRING_MIDDLE)
+                                 (x) == FSTRING_MIDDLE   || \\
+                                 (x) == TSTRING_MIDDLE)
 
 
 // Export these 4 symbols for 'test_peg_generator'
@@ -278,13 +278,13 @@ def make_rst(infile, outfile='Doc/library/token-list.inc',
 %s
 }
 
-def ISTERMINAL(x):
+def ISTERMINAL(x: int) -> bool:
     return x < NT_OFFSET
 
-def ISNONTERMINAL(x):
+def ISNONTERMINAL(x: int) -> bool:
     return x >= NT_OFFSET
 
-def ISEOF(x):
+def ISEOF(x: int) -> bool:
     return x == ENDMARKER
 '''
 
diff --git a/Tools/build/mypy.ini b/Tools/build/mypy.ini
index 13d47b9..2abb21e 100644
--- a/Tools/build/mypy.ini
+++ b/Tools/build/mypy.ini
@@ -6,6 +6,7 @@ files =
     Tools/build/check_extension_modules.py,
     Tools/build/compute-changes.py,
     Tools/build/deepfreeze.py,
+    Tools/build/generate-build-details.py,
     Tools/build/generate_sbom.py,
     Tools/build/generate_stdlib_module_names.py,
     Tools/build/verify_ensurepip_wheels.py,
diff --git a/Tools/build/parse_html5_entities.py b/Tools/build/parse_html5_entities.py
index d2bf290..aca9849 100644
--- a/Tools/build/parse_html5_entities.py
+++ b/Tools/build/parse_html5_entities.py
@@ -12,11 +12,11 @@
 Written by Ezio Melotti and Iuliia Proskurnia.
 """
 
+import json
 import os
 import sys
-import json
-from urllib.request import urlopen
 from html.entities import html5
+from urllib.request import urlopen
 
 SCRIPT_NAME = 'Tools/build/parse_html5_entities.py'
 PAGE_URL = 'https://html.spec.whatwg.org/multipage/named-characters.html'
@@ -40,20 +40,20 @@ def compare_dicts(old, new):
     """Compare the old and new dicts and print the differences."""
     added = new.keys() - old.keys()
     if added:
-        print('{} entitie(s) have been added:'.format(len(added)))
+        print(f'{len(added)} entitie(s) have been added:')
         for name in sorted(added):
-            print('  {!r}: {!r}'.format(name, new[name]))
+            print(f'  {name!r}: {new[name]!r}')
     removed = old.keys() - new.keys()
     if removed:
-        print('{} entitie(s) have been removed:'.format(len(removed)))
+        print(f'{len(removed)} entitie(s) have been removed:')
         for name in sorted(removed):
-            print('  {!r}: {!r}'.format(name, old[name]))
+            print(f'  {name!r}: {old[name]!r}')
     changed = set()
     for name in (old.keys() & new.keys()):
         if old[name] != new[name]:
             changed.add((name, old[name], new[name]))
     if changed:
-        print('{} entitie(s) have been modified:'.format(len(changed)))
+        print(f'{len(changed)} entitie(s) have been modified:')
         for item in sorted(changed):
             print('  {!r}: {!r} -> {!r}'.format(*item))
 
@@ -111,5 +111,5 @@ def write_items(entities, file=sys.stdout):
             print('The current dictionary is updated.')
         else:
             compare_dicts(html5, new_html5)
-            print('Run "./python {0} --patch" to update Lib/html/entities.html '
-                  'or "./python {0} --create" to see the generated ' 'dictionary.'.format(__file__))
+            print(f'Run "./python {__file__} --patch" to update Lib/html/entities.html '
+                  f'or "./python {__file__} --create" to see the generated dictionary.')
diff --git a/Tools/build/regen-configure.sh b/Tools/build/regen-configure.sh
index e1ecefd..c7683eb 100644
--- a/Tools/build/regen-configure.sh
+++ b/Tools/build/regen-configure.sh
@@ -5,7 +5,7 @@ set -e -x
 # The check_autoconf_regen job of .github/workflows/build.yml must kept in
 # sync with this script. Use the same container image than the job so the job
 # doesn't need to run autoreconf in a container.
-IMAGE="ghcr.io/python/autoconf:2024.10.16.11360930377"
+IMAGE="ghcr.io/python/autoconf:2025.01.02.12581854023"
 AUTORECONF="autoreconf -ivf -Werror"
 
 WORK_DIR="/src"
diff --git a/Tools/build/smelly.py b/Tools/build/smelly.py
index 7c53426..9a36041 100644
--- a/Tools/build/smelly.py
+++ b/Tools/build/smelly.py
@@ -6,7 +6,6 @@
 import sys
 import sysconfig
 
-
 ALLOWED_PREFIXES = ('Py', '_Py')
 if sys.platform == 'darwin':
     ALLOWED_PREFIXES += ('__Py',)
@@ -52,8 +51,8 @@ def get_exported_symbols(library, dynamic=False):
     if dynamic:
         args.append('--dynamic')
     args.append(library)
-    print("+ %s" % ' '.join(args))
-    proc = subprocess.run(args, stdout=subprocess.PIPE, universal_newlines=True)
+    print(f"+ {' '.join(args)}")
+    proc = subprocess.run(args, stdout=subprocess.PIPE, encoding='utf-8')
     if proc.returncode:
         sys.stdout.write(proc.stdout)
         sys.exit(proc.returncode)
@@ -80,7 +79,7 @@ def get_smelly_symbols(stdout, dynamic=False):
 
         symtype = parts[1].strip()
         symbol = parts[-1]
-        result = '%s (type: %s)' % (symbol, symtype)
+        result = f'{symbol} (type: {symtype})'
 
         if (symbol.startswith(ALLOWED_PREFIXES) or
             symbol in EXCEPTIONS or
@@ -111,10 +110,10 @@ def check_library(library, dynamic=False):
     print()
     smelly_symbols.sort()
     for symbol in smelly_symbols:
-        print("Smelly symbol: %s" % symbol)
+        print(f"Smelly symbol: {symbol}")
 
     print()
-    print("ERROR: Found %s smelly symbols!" % len(smelly_symbols))
+    print(f"ERROR: Found {len(smelly_symbols)} smelly symbols!")
     return len(smelly_symbols)
 
 
diff --git a/Tools/build/stable_abi.py b/Tools/build/stable_abi.py
index f7fccb6..1ddd76c 100644
--- a/Tools/build/stable_abi.py
+++ b/Tools/build/stable_abi.py
@@ -7,24 +7,26 @@
 (relative to the manifest file, as they appear in the CPython codebase).
 """
 
-from functools import partial
-from pathlib import Path
-import dataclasses
-import subprocess
-import sysconfig
 import argparse
-import textwrap
-import tomllib
+import csv
+import dataclasses
 import difflib
-import pprint
-import sys
+import io
 import os
 import os.path
-import io
+import pprint
 import re
-import csv
+import subprocess
+import sys
+import sysconfig
+import textwrap
+import tomllib
+from functools import partial
+from pathlib import Path
 
 SCRIPT_NAME = 'Tools/build/stable_abi.py'
+DEFAULT_MANIFEST_PATH = (
+    Path(__file__).parent / '../../Misc/stable_abi.toml').resolve()
 MISSING = object()
 
 EXCLUDED_HEADERS = {
@@ -55,7 +57,7 @@
 class Manifest:
     """Collection of `ABIItem`s forming the stable ABI/limited API."""
     def __init__(self):
-        self.contents = dict()
+        self.contents = {}
 
     def add(self, item):
         if item.name in self.contents:
@@ -402,22 +404,20 @@ def do_unixy_check(manifest, args):
     # Get all macros first: we'll need feature macros like HAVE_FORK and
     # MS_WINDOWS for everything else
     present_macros = gcc_get_limited_api_macros(['Include/Python.h'])
-    feature_macros = set(m.name for m in manifest.select({'feature_macro'}))
+    feature_macros = {m.name for m in manifest.select({'feature_macro'})}
     feature_macros &= present_macros
 
     # Check that we have all needed macros
-    expected_macros = set(
-        item.name for item in manifest.select({'macro'})
-    )
+    expected_macros = {item.name for item in manifest.select({'macro'})}
     missing_macros = expected_macros - present_macros
     okay &= _report_unexpected_items(
         missing_macros,
-        'Some macros from are not defined from "Include/Python.h"'
-        + 'with Py_LIMITED_API:')
+        'Some macros from are not defined from "Include/Python.h" '
+        'with Py_LIMITED_API:')
 
-    expected_symbols = set(item.name for item in manifest.select(
+    expected_symbols = {item.name for item in manifest.select(
         {'function', 'data'}, include_abi_only=True, ifdef=feature_macros,
-    ))
+    )}
 
     # Check the static library (*.a)
     LIBRARY = sysconfig.get_config_var("LIBRARY")
@@ -435,15 +435,15 @@ def do_unixy_check(manifest, args):
             manifest, LDLIBRARY, expected_symbols, dynamic=False)
 
     # Check definitions in the header files
-    expected_defs = set(item.name for item in manifest.select(
+    expected_defs = {item.name for item in manifest.select(
         {'function', 'data'}, include_abi_only=False, ifdef=feature_macros,
-    ))
+    )}
     found_defs = gcc_get_limited_api_definitions(['Include/Python.h'])
     missing_defs = expected_defs - found_defs
     okay &= _report_unexpected_items(
         missing_defs,
         'Some expected declarations were not declared in '
-        + '"Include/Python.h" with Py_LIMITED_API:')
+        '"Include/Python.h" with Py_LIMITED_API:')
 
     # Some Limited API macros are defined in terms of private symbols.
     # These are not part of Limited API (even though they're defined with
@@ -453,7 +453,7 @@ def do_unixy_check(manifest, args):
     okay &= _report_unexpected_items(
         extra_defs,
         'Some extra declarations were found in "Include/Python.h" '
-        + 'with Py_LIMITED_API:')
+        'with Py_LIMITED_API:')
 
     return okay
 
@@ -475,7 +475,7 @@ def binutils_get_exported_symbols(library, dynamic=False):
     if dynamic:
         args.append("--dynamic")
     args.append(library)
-    proc = subprocess.run(args, stdout=subprocess.PIPE, universal_newlines=True)
+    proc = subprocess.run(args, stdout=subprocess.PIPE, encoding='utf-8')
     if proc.returncode:
         sys.stdout.write(proc.stdout)
         sys.exit(proc.returncode)
@@ -545,15 +545,10 @@ def gcc_get_limited_api_macros(headers):
             "-E",
         ]
         + [str(file) for file in headers],
-        text=True,
+        encoding='utf-8',
     )
 
-    return {
-        target
-        for target in re.findall(
-            r"#define (\w+)", preprocessor_output_with_macros
-        )
-    }
+    return set(re.findall(r"#define (\w+)", preprocessor_output_with_macros))
 
 
 def gcc_get_limited_api_definitions(headers):
@@ -588,7 +583,7 @@ def gcc_get_limited_api_definitions(headers):
             "-E",
         ]
         + [str(file) for file in headers],
-        text=True,
+        encoding='utf-8',
         stderr=subprocess.DEVNULL,
     )
     stable_functions = set(
@@ -611,7 +606,7 @@ def check_private_names(manifest):
         if name.startswith('_') and not item.abi_only:
             raise ValueError(
                 f'`{name}` is private (underscore-prefixed) and should be '
-                + 'removed from the stable ABI list or marked `abi_only`')
+                'removed from the stable ABI list or marked `abi_only`')
 
 def check_dump(manifest, filename):
     """Check that manifest.dump() corresponds to the data.
@@ -622,7 +617,7 @@ def check_dump(manifest, filename):
     with filename.open('rb') as file:
         from_file = tomllib.load(file)
     if dumped != from_file:
-        print(f'Dump differs from loaded data!', file=sys.stderr)
+        print('Dump differs from loaded data!', file=sys.stderr)
         diff = difflib.unified_diff(
             pprint.pformat(dumped).splitlines(),
             pprint.pformat(from_file).splitlines(),
@@ -641,8 +636,9 @@ def main():
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.add_argument(
-        "file", type=Path, metavar='FILE',
-        help="file with the stable abi manifest",
+        "file", type=Path, metavar='FILE', nargs='?',
+        default=DEFAULT_MANIFEST_PATH,
+        help=f"file with the stable abi manifest (default: {DEFAULT_MANIFEST_PATH})",
     )
     parser.add_argument(
         "--generate", action='store_true',
@@ -651,7 +647,7 @@ def main():
     parser.add_argument(
         "--generate-all", action='store_true',
         help="as --generate, but generate all file(s) using default filenames."
-            + " (unlike --all, does not run any extra checks)",
+             " (unlike --all, does not run any extra checks)",
     )
     parser.add_argument(
         "-a", "--all", action='store_true',
@@ -684,7 +680,7 @@ def main():
 
     if args.list:
         for gen in generators:
-            print(f'{gen.arg_name}: {base_path / gen.default_path}')
+            print(f'{gen.arg_name}: {(base_path / gen.default_path).resolve()}')
         sys.exit(0)
 
     run_all_generators = args.generate_all
@@ -735,8 +731,10 @@ def main():
 
     if not results:
         if args.generate:
-            parser.error('No file specified. Use --help for usage.')
-        parser.error('No check specified. Use --help for usage.')
+            parser.error('No file specified. Use --generate-all to regenerate '
+                         'all files, or --help for usage.')
+        parser.error('No check specified. Use --all to check all files, '
+                     'or --help for usage.')
 
     failed_results = [name for name, result in results.items() if not result]
 
diff --git a/Tools/build/umarshal.py b/Tools/build/umarshal.py
index e89ba02..865cffc 100644
--- a/Tools/build/umarshal.py
+++ b/Tools/build/umarshal.py
@@ -1,8 +1,7 @@
 # Implementation of marshal.loads() in pure Python
 
 import ast
-
-from typing import Any, Tuple
+from typing import Any
 
 
 class Type:
@@ -55,10 +54,10 @@ def __init__(self, **kwds: Any):
     def __repr__(self) -> str:
         return f"Code(**{self.__dict__})"
 
-    co_localsplusnames: Tuple[str]
-    co_localspluskinds: Tuple[int]
+    co_localsplusnames: tuple[str, ...]
+    co_localspluskinds: tuple[int, ...]
 
-    def get_localsplus_names(self, select_kind: int) -> Tuple[str, ...]:
+    def get_localsplus_names(self, select_kind: int) -> tuple[str, ...]:
         varnames: list[str] = []
         for name, kind in zip(self.co_localsplusnames,
                               self.co_localspluskinds):
@@ -67,15 +66,15 @@ def get_localsplus_names(self, select_kind: int) -> Tuple[str, ...]:
         return tuple(varnames)
 
     @property
-    def co_varnames(self) -> Tuple[str, ...]:
+    def co_varnames(self) -> tuple[str, ...]:
         return self.get_localsplus_names(CO_FAST_LOCAL)
 
     @property
-    def co_cellvars(self) -> Tuple[str, ...]:
+    def co_cellvars(self) -> tuple[str, ...]:
         return self.get_localsplus_names(CO_FAST_CELL)
 
     @property
-    def co_freevars(self) -> Tuple[str, ...]:
+    def co_freevars(self) -> tuple[str, ...]:
         return self.get_localsplus_names(CO_FAST_FREE)
 
     @property
@@ -309,7 +308,8 @@ def loads(data: bytes) -> Any:
 
 def main() -> None:
     # Test
-    import marshal, pprint
+    import marshal
+    import pprint
     sample = {'foo': {(42, "bar", 3.14)}}
     data = marshal.dumps(sample)
     retval = loads(data)
diff --git a/Tools/c-analyzer/TODO b/Tools/c-analyzer/TODO
index 3d59953..2077534 100644
--- a/Tools/c-analyzer/TODO
+++ b/Tools/c-analyzer/TODO
@@ -69,7 +69,6 @@ Objects/tupleobject.c:_Py_tuple_zero_allocs                      Py_ssize_t _Py_
 Objects/typeobject.c:next_version_tag                            static unsigned int next_version_tag
 Python/Python-ast.c:init_types():initialized                     static int initialized
 Python/bootstrap_hash.c:urandom_cache                            static struct { int fd; dev_t st_dev; ino_t st_ino; } urandom_cache
-Python/ceval.c:lltrace                                           static int lltrace
 Python/ceval.c:make_pending_calls():busy                         static int busy
 Python/dynload_shlib.c:handles                                   static struct { dev_t dev; ino_t ino; void *handle; } handles[128]
 Python/dynload_shlib.c:nhandles                                  static int nhandles
@@ -533,7 +532,7 @@ Python/pythonrun.c:PyId_stdin                                    _Py_IDENTIFIER(
 Python/pythonrun.c:PyId_stdout                                   _Py_IDENTIFIER(stdout)
 Python/pythonrun.c:PyRun_InteractiveOneObjectEx():PyId___main__  _Py_IDENTIFIER(__main__)
 Python/pythonrun.c:PyRun_InteractiveOneObjectEx():PyId_encoding  _Py_IDENTIFIER(encoding)
-Python/pythonrun.c:_Py_HandleSystemExit():PyId_code              _Py_IDENTIFIER(code)
+Python/pythonrun.c:_Py_HandleSystemExitAndKeyboardInterrupt():PyId_code _Py_IDENTIFIER(code)
 Python/pythonrun.c:parse_syntax_error():PyId_filename            _Py_IDENTIFIER(filename)
 Python/pythonrun.c:parse_syntax_error():PyId_lineno              _Py_IDENTIFIER(lineno)
 Python/pythonrun.c:parse_syntax_error():PyId_msg                 _Py_IDENTIFIER(msg)
@@ -562,8 +561,6 @@ Objects/unicodeobject.c:static_strings                           static _Py_Iden
 
 # PyTypeObject (311)
 Modules/_abc.c:_abc_data_type                                    static PyTypeObject _abc_data_type
-Modules/_blake2/blake2b_impl.c:PyBlake2_BLAKE2bType              PyTypeObject PyBlake2_BLAKE2bType
-Modules/_blake2/blake2s_impl.c:PyBlake2_BLAKE2sType              PyTypeObject PyBlake2_BLAKE2sType
 Modules/_collectionsmodule.c:defdict_type                        static PyTypeObject defdict_type
 Modules/_collectionsmodule.c:deque_type                          static PyTypeObject deque_type
 Modules/_collectionsmodule.c:dequeiter_type                      static PyTypeObject dequeiter_type
@@ -797,6 +794,7 @@ Objects/genobject.c:_PyAsyncGenASend_Type                        PyTypeObject _P
 Objects/genobject.c:_PyAsyncGenAThrow_Type                       PyTypeObject _PyAsyncGenAThrow_Type
 Objects/genobject.c:_PyAsyncGenWrappedValue_Type                 PyTypeObject _PyAsyncGenWrappedValue_Type
 Objects/genobject.c:_PyCoroWrapper_Type                          PyTypeObject _PyCoroWrapper_Type
+Objects/interpolationobject.c:_PyInterpolation_Type              PyTypeObject _PyInterpolation_Type
 Objects/interpreteridobject.c:_PyInterpreterID_Type              PyTypeObject _PyInterpreterID_Type
 Objects/iterobject.c:PyCallIter_Type                             PyTypeObject PyCallIter_Type
 Objects/iterobject.c:PySeqIter_Type                              PyTypeObject PySeqIter_Type
@@ -830,6 +828,8 @@ Objects/sliceobject.c:PyEllipsis_Type                            PyTypeObject Py
 Objects/sliceobject.c:PySlice_Type                               PyTypeObject PySlice_Type
 Objects/stringlib/unicode_format.h:PyFieldNameIter_Type          static PyTypeObject PyFieldNameIter_Type
 Objects/stringlib/unicode_format.h:PyFormatterIter_Type          static PyTypeObject PyFormatterIter_Type
+Objects/templateobject.c:_PyTemplateIter_Type                    PyTypeObject _PyTemplateIter_Type
+Objects/templateobject.c:_PyTemplate_Type                        PyTypeObject _PyTemplate_Type
 Objects/tupleobject.c:PyTupleIter_Type                           PyTypeObject PyTupleIter_Type
 Objects/tupleobject.c:PyTuple_Type                               PyTypeObject PyTuple_Type
 Objects/typeobject.c:PyBaseObject_Type                           PyTypeObject PyBaseObject_Type
diff --git a/Tools/c-analyzer/c_analyzer/datafiles.py b/Tools/c-analyzer/c_analyzer/datafiles.py
index d5db3bd..79c201a 100644
--- a/Tools/c-analyzer/c_analyzer/datafiles.py
+++ b/Tools/c-analyzer/c_analyzer/datafiles.py
@@ -104,7 +104,12 @@ def _iter_ignored(infile, relroot):
                               for v in varidinfo)
         if reason in bogus:
             reason = None
-        varid = _info.DeclID.from_row(varidinfo)
+        try:
+            varid = _info.DeclID.from_row(varidinfo)
+        except BaseException as e:
+            e.add_note(f"Error occurred when processing row {varidinfo} in {infile}.")
+            e.add_note(f"Could it be that you added a row which is not tab-delimited?")
+            raise e
         varid = varid.fix_filename(relroot, formatted=False, fixroot=False)
         yield varid, reason
 
diff --git a/Tools/c-analyzer/c_parser/parser/__init__.py b/Tools/c-analyzer/c_parser/parser/__init__.py
index 4227e93..ff4f303 100644
--- a/Tools/c-analyzer/c_parser/parser/__init__.py
+++ b/Tools/c-analyzer/c_parser/parser/__init__.py
@@ -164,7 +164,7 @@ def _parse(srclines, anon_name, **srckwargs):
 # We use defaults that cover most files.  Files with bigger declarations
 # are covered elsewhere (MAX_SIZES in cpython/_parser.py).
 
-def _iter_source(lines, *, maxtext=10_000, maxlines=200, showtext=False):
+def _iter_source(lines, *, maxtext=11_000, maxlines=200, showtext=False):
     maxtext = maxtext if maxtext and maxtext > 0 else None
     maxlines = maxlines if maxlines and maxlines > 0 else None
     filestack = []
diff --git a/Tools/c-analyzer/c_parser/parser/_regexes.py b/Tools/c-analyzer/c_parser/parser/_regexes.py
index 5695daf..c1a8ab3 100644
--- a/Tools/c-analyzer/c_parser/parser/_regexes.py
+++ b/Tools/c-analyzer/c_parser/parser/_regexes.py
@@ -72,6 +72,7 @@ def _ind(text, level=1, edges='both'):
             long |
             float |
             double |
+            _Complex |
             void |
 
             struct |
@@ -121,6 +122,16 @@ def _ind(text, level=1, edges='both'):
             |
             (?: signed | unsigned )  # implies int
             |
+            (?:
+                (?: (?: float | double | long\s+double ) \s+ )?
+                _Complex
+            )
+            |
+            (?:
+                _Complex
+                (?: \s+ (?: float | double | long\s+double ) )?
+            )
+            |
             (?:
                 (?: (?: signed | unsigned ) \s+ )?
                 (?: (?: long | short ) \s+ )?
diff --git a/Tools/c-analyzer/cpython/_analyzer.py b/Tools/c-analyzer/cpython/_analyzer.py
index f07fa8a..6204353 100644
--- a/Tools/c-analyzer/cpython/_analyzer.py
+++ b/Tools/c-analyzer/cpython/_analyzer.py
@@ -280,12 +280,26 @@ def _is_kwlist(decl):
     vartype = ''.join(str(decl.vartype).split())
     return vartype == 'char*[]'
 
+def _is_local_static_mutex(decl):
+    if not hasattr(decl, "vartype"):
+        return False
+
+    if not hasattr(decl, "parent") or decl.parent is None:
+        # We only want to allow local variables
+        return False
+
+    vartype = decl.vartype
+    return (vartype.typespec == 'PyMutex') and (decl.storage == 'static')
 
 def _has_other_supported_type(decl):
     if hasattr(decl, 'file') and decl.file.filename.endswith('.c.h'):
         assert 'clinic' in decl.file.filename, (decl,)
         if decl.name == '_kwtuple':
             return True
+    if _is_local_static_mutex(decl):
+        # GH-127081: Local static mutexes are used to
+        # wrap libc functions that aren't thread safe
+        return True
     vartype = str(decl.vartype).split()
     if vartype[0] == 'struct':
         vartype = vartype[1:]
diff --git a/Tools/c-analyzer/cpython/_parser.py b/Tools/c-analyzer/cpython/_parser.py
index 12010f0..1e75404 100644
--- a/Tools/c-analyzer/cpython/_parser.py
+++ b/Tools/c-analyzer/cpython/_parser.py
@@ -66,13 +66,12 @@ def clean_lines(text):
 Python/dynload_dl.c             # dl.h
 Python/dynload_hpux.c           # dl.h
 Python/emscripten_signal.c
+Python/emscripten_syscalls.c
 Python/thread_pthread.h
 Python/thread_pthread_stubs.h
 
 # only huge constants (safe but parsing is slow)
-Modules/_ssl_data_31.h
-Modules/_ssl_data_300.h
-Modules/_ssl_data_111.h
+Modules/_ssl_data_*.h
 Modules/cjkcodecs/mappings_*.h
 Modules/unicodedata_db.h
 Modules/unicodename_db.h
@@ -84,6 +83,8 @@ def clean_lines(text):
 Python/generated_cases.c.h
 Python/executor_cases.c.h
 Python/optimizer_cases.c.h
+# XXX: Throws errors if PY_VERSION_HEX is not mocked out
+Modules/clinic/_testclinic_depr.c.h
 
 # not actually source
 Python/bytecodes.c
@@ -120,11 +121,15 @@ def clean_lines(text):
 Modules/_decimal/**/*.c	Modules/_decimal/libmpdec
 Modules/_elementtree.c	Modules/expat
 Modules/_hacl/*.c	Modules/_hacl/include
+Modules/_hacl/*.c	Modules/_hacl/
 Modules/_hacl/*.h	Modules/_hacl/include
+Modules/_hacl/*.h	Modules/_hacl/
 Modules/md5module.c	Modules/_hacl/include
 Modules/sha1module.c	Modules/_hacl/include
 Modules/sha2module.c	Modules/_hacl/include
 Modules/sha3module.c	Modules/_hacl/include
+Modules/blake2module.c	Modules/_hacl/include
+Modules/hmacmodule.c	Modules/_hacl/include
 Objects/stringlib/*.h	Objects
 
 # possible system-installed headers, just in case
@@ -167,6 +172,7 @@ def clean_lines(text):
 Objects/stringlib/find.h	Objects/stringlib/fastsearch.h
 Objects/stringlib/partition.h	Objects/stringlib/fastsearch.h
 Objects/stringlib/replace.h	Objects/stringlib/fastsearch.h
+Objects/stringlib/repr.h	Objects/stringlib/fastsearch.h
 Objects/stringlib/split.h	Objects/stringlib/fastsearch.h
 
 # @end=tsv@
@@ -286,6 +292,7 @@ def clean_lines(text):
 Modules/_sre/sre_lib.h	LOCAL(type)	static inline type
 Modules/_sre/sre_lib.h	SRE(F)	sre_ucs2_##F
 Objects/stringlib/codecs.h	STRINGLIB_IS_UNICODE	1
+Include/internal/pycore_crossinterp_data_registry.h	Py_CORE_CROSSINTERP_DATA_REGISTRY_H	1
 
 # @end=tsv@
 ''')[1:]
@@ -325,6 +332,7 @@ def clean_lines(text):
     _abs('Python/parking_lot.c'): (40_000, 1000),
     _abs('Python/pylifecycle.c'): (500_000, 5000),
     _abs('Python/pystate.c'): (500_000, 5000),
+    _abs('Python/initconfig.c'): (50_000, 500),
 
     # Generated files:
     _abs('Include/internal/pycore_opcode.h'): (10_000, 1000),
diff --git a/Tools/c-analyzer/cpython/globals-to-fix.tsv b/Tools/c-analyzer/cpython/globals-to-fix.tsv
index 06e58e9..3c3cb2f 100644
--- a/Tools/c-analyzer/cpython/globals-to-fix.tsv
+++ b/Tools/c-analyzer/cpython/globals-to-fix.tsv
@@ -55,6 +55,7 @@ Objects/genobject.c	-	_PyAsyncGenASend_Type	-
 Objects/genobject.c	-	_PyAsyncGenAThrow_Type	-
 Objects/genobject.c	-	_PyAsyncGenWrappedValue_Type	-
 Objects/genobject.c	-	_PyCoroWrapper_Type	-
+Objects/interpolationobject.c	-	_PyInterpolation_Type	-
 Objects/iterobject.c	-	PyCallIter_Type	-
 Objects/iterobject.c	-	PySeqIter_Type	-
 Objects/iterobject.c	-	_PyAnextAwaitable_Type	-
@@ -86,6 +87,8 @@ Objects/setobject.c	-	PySetIter_Type	-
 Objects/setobject.c	-	PySet_Type	-
 Objects/sliceobject.c	-	PyEllipsis_Type	-
 Objects/sliceobject.c	-	PySlice_Type	-
+Objects/templateobject.c	-	_PyTemplateIter_Type	-
+Objects/templateobject.c	-	_PyTemplate_Type	-
 Objects/tupleobject.c	-	PyTupleIter_Type	-
 Objects/tupleobject.c	-	PyTuple_Type	-
 Objects/typeobject.c	-	_PyBufferWrapper_Type	-
@@ -106,6 +109,8 @@ Python/context.c	-	PyContextToken_Type	-
 Python/context.c	-	PyContextVar_Type	-
 Python/context.c	-	PyContext_Type	-
 Python/instruction_sequence.c	-	_PyInstructionSequence_Type	-
+Python/instrumentation.c	-	_PyLegacyBranchEventHandler_Type	-
+Python/instrumentation.c	-	_PyBranchesIterator	-
 Python/traceback.c	-	PyTraceBack_Type	-
 
 ##-----------------------
@@ -358,38 +363,6 @@ Modules/_testclinic.c	-	TestClass	-
 ##-----------------------
 ## static types
 
-Modules/_ctypes/_ctypes.c	-	PyCArrayType_Type	-
-Modules/_ctypes/_ctypes.c	-	PyCArray_Type	-
-Modules/_ctypes/_ctypes.c	-	PyCData_Type	-
-Modules/_ctypes/_ctypes.c	-	PyCFuncPtrType_Type	-
-Modules/_ctypes/_ctypes.c	-	PyCFuncPtr_Type	-
-Modules/_ctypes/_ctypes.c	-	PyCPointerType_Type	-
-Modules/_ctypes/_ctypes.c	-	PyCPointer_Type	-
-Modules/_ctypes/_ctypes.c	-	PyCSimpleType_Type	-
-Modules/_ctypes/_ctypes.c	-	PyCStructType_Type	-
-Modules/_ctypes/_ctypes.c	-	Simple_Type	-
-Modules/_ctypes/_ctypes.c	-	Struct_Type	-
-Modules/_ctypes/_ctypes.c	-	UnionType_Type	-
-Modules/_ctypes/_ctypes.c	-	Union_Type	-
-Modules/_ctypes/callproc.c	-	PyCArg_Type	-
-Modules/_ctypes/ctypes.h	-	PyCArg_Type	-
-Modules/_ctypes/ctypes.h	-	PyCArrayType_Type	-
-Modules/_ctypes/ctypes.h	-	PyCArray_Type	-
-Modules/_ctypes/ctypes.h	-	PyCData_Type	-
-Modules/_ctypes/ctypes.h	-	PyCFuncPtrType_Type	-
-Modules/_ctypes/ctypes.h	-	PyCFuncPtr_Type	-
-Modules/_ctypes/ctypes.h	-	PyCPointerType_Type	-
-Modules/_ctypes/ctypes.h	-	PyCPointer_Type	-
-Modules/_ctypes/ctypes.h	-	PyCSimpleType_Type	-
-Modules/_ctypes/ctypes.h	-	PyCStgDict_Type	-
-Modules/_ctypes/ctypes.h	-	PyCStructType_Type	-
-Modules/_ctypes/ctypes.h	-	PyExc_ArgError	-
-Modules/_ctypes/ctypes.h	-	_ctypes_conversion_encoding	-
-Modules/_ctypes/ctypes.h	-	_ctypes_conversion_errors	-
-Modules/_ctypes/ctypes.h	-	_ctypes_ptrtype_cache	-
-Modules/_ctypes/ctypes.h	-	basespec_string	-
-Modules/_ctypes/stgdict.c	-	PyCStgDict_Type	-
-Modules/_cursesmodule.c	-	PyCursesWindow_Type	-
 Modules/_datetimemodule.c	-	PyDateTime_DateTimeType	-
 Modules/_datetimemodule.c	-	PyDateTime_DateType	-
 Modules/_datetimemodule.c	-	PyDateTime_DeltaType	-
@@ -414,31 +387,14 @@ Modules/_tkinter.c	-	Tktt_Type	-
 Modules/xxlimited_35.c	-	Xxo_Type	-
 
 ## exception types
-Modules/_ctypes/_ctypes.c	-	PyExc_ArgError	-
-Modules/_cursesmodule.c	-	PyCursesError	-
 Modules/_tkinter.c	-	Tkinter_TclError	-
 Modules/xxlimited_35.c	-	ErrorObject	-
 Modules/xxmodule.c	-	ErrorObject	-
 
-##-----------------------
-## cached - initialized once
-
-## manually cached PyUnicodeOjbect
-Modules/_ctypes/callproc.c	_ctypes_get_errobj	error_object_name	-
-Modules/_ctypes/_ctypes.c	CreateSwappedType	swapped_suffix	-
-
 ##-----------------------
 ## other
 
-## initialized once
-Modules/_ctypes/_ctypes.c	-	_unpickle	-
-Modules/_ctypes/_ctypes.c	PyCArrayType_from_ctype	array_cache	-
-Modules/_cursesmodule.c	-	ModDict	-
-
 ## state
-Modules/_ctypes/_ctypes.c	-	_ctypes_ptrtype_cache	-
-Modules/_ctypes/_ctypes.c	-	global_state	-
-Modules/_ctypes/ctypes.h	-	global_state	-
 Modules/_datetimemodule.c	-	_datetime_global_state	-
 Modules/_tkinter.c	-	tcl_lock	-
 Modules/_tkinter.c	-	excInCmd	-
@@ -454,12 +410,14 @@ Modules/_tkinter.c	-	trbInCmd	-
 
 ## other
 Include/datetime.h	-	PyDateTimeAPI	-
-Modules/_ctypes/cfield.c	_ctypes_get_fielddesc	initialized	-
+Modules/_ctypes/cfield.c	_ctypes_init_fielddesc	initialized	-
+Modules/_ctypes/cfield.c	-	formattable	-
 Modules/_ctypes/malloc_closure.c	-	_pagesize	-
-Modules/_cursesmodule.c	-	initialised	-
-Modules/_cursesmodule.c	-	initialised_setupterm	-
-Modules/_cursesmodule.c	-	initialisedcolors	-
-Modules/_cursesmodule.c	-	screen_encoding	-
+Modules/_cursesmodule.c	-	curses_module_loaded	-
+Modules/_cursesmodule.c	-	curses_initscr_called	-
+Modules/_cursesmodule.c	-	curses_setupterm_called	-
+Modules/_cursesmodule.c	-	curses_start_color_called	-
+Modules/_cursesmodule.c	-	curses_screen_encoding	-
 Modules/_elementtree.c	-	expat_capi	-
 Modules/readline.c	-	libedit_append_replace_history_offset	-
 Modules/readline.c	-	using_libedit_emulation	-
@@ -468,7 +426,6 @@ Modules/readline.c	-	libedit_history_start	-
 ##-----------------------
 ## state
 
-Modules/_ctypes/cfield.c	-	formattable	-
 Modules/_ctypes/malloc_closure.c	-	free_list	-
 Modules/_curses_panel.c	-	lop	-
 Modules/_ssl/debughelpers.c	_PySSL_keylog_callback	lock	-
@@ -490,3 +447,5 @@ Modules/readline.c	-	completed_input_string	-
 Modules/rotatingtree.c	-	random_stream	-
 Modules/rotatingtree.c	-	random_value	-
 Modules/rotatingtree.c	-	random_mutex	-
+Modules/socketmodule.c	-	accept4_works	-
+Modules/socketmodule.c	-	sock_cloexec_works	-
diff --git a/Tools/c-analyzer/cpython/ignored.tsv b/Tools/c-analyzer/cpython/ignored.tsv
index 5e271a5..d5d806b 100644
--- a/Tools/c-analyzer/cpython/ignored.tsv
+++ b/Tools/c-analyzer/cpython/ignored.tsv
@@ -28,11 +28,13 @@ Python/thread_pthread.h	PyThread__init_thread	lib_initialized	-
 ##-----------------------
 ## other values (not Python-specific)
 
+# static tables computed by external script
+Objects/longobject.c	-	log_base_BASE	-
+Objects/longobject.c	-	convwidth_base	-
+Objects/longobject.c	-	convmultmax_base	-
+
 ## cached computed data - set lazily (*after* first init)
 # XXX Are these safe relative to write races?
-Objects/longobject.c	long_from_non_binary_base	log_base_BASE	-
-Objects/longobject.c	long_from_non_binary_base	convwidth_base	-
-Objects/longobject.c	long_from_non_binary_base	convmultmax_base	-
 Objects/unicodeobject.c	-	bloom_linebreak	-
 # This is safe:
 Objects/unicodeobject.c	_init_global_state	initialized	-
@@ -53,6 +55,9 @@ Python/pyhash.c	-	_Py_HashSecret	-
 ## thread-safe hashtable (internal locks)
 Python/parking_lot.c	-	buckets	-
 
+## data needed for introspecting asyncio state from debuggers and profilers
+Modules/_asynciomodule.c	-	_AsyncioDebug	-
+
 
 ##################################
 ## state tied to Py_Main()
@@ -90,6 +95,7 @@ Python/initconfig.c	-	_Py_StandardStreamErrors	-
 
 # Internal constant list
 Python/initconfig.c	-	PYCONFIG_SPEC	-
+Python/initconfig.c	-	PYPRECONFIG_SPEC	-
 
 
 ##-----------------------
@@ -160,6 +166,8 @@ Python/sysmodule.c	-	_preinit_xoptions	-
 # thread-safety
 # XXX need race protection?
 Modules/faulthandler.c	faulthandler_dump_traceback	reentrant	-
+Modules/faulthandler.c	faulthandler_dump_c_stack	reentrant	-
+Modules/grpmodule.c	-	group_db_mutex	-
 Python/pylifecycle.c	_Py_FatalErrorFormat	reentrant	-
 Python/pylifecycle.c	fatal_error	reentrant	-
 
@@ -302,6 +310,7 @@ Modules/cmathmodule.c	-	tanh_special_values	-
 Modules/config.c	-	_PyImport_Inittab	-
 Modules/faulthandler.c	-	faulthandler_handlers	-
 Modules/getnameinfo.c	-	gni_afdl	-
+Modules/hmacmodule.c	-	py_hmac_static_hinfo	-
 Modules/posixmodule.c	os_getxattr_impl	buffer_sizes	-
 Modules/posixmodule.c	os_listxattr_impl	buffer_sizes	-
 Modules/posixmodule.c	-	posix_constants_confstr	-
@@ -318,6 +327,7 @@ Objects/exceptions.c	-	static_exceptions	-
 Objects/genobject.c	-	ASYNC_GEN_IGNORED_EXIT_MSG	-
 Objects/genobject.c	-	NON_INIT_CORO_MSG	-
 Objects/longobject.c	-	_PyLong_DigitValue	-
+Objects/longobject.c	-	PyLong_LAYOUT	-
 Objects/object.c	-	_Py_SwappedOp	-
 Objects/object.c	-	_Py_abstract_hack	-
 Objects/object.c	-	last_final_reftotal	-
@@ -340,13 +350,12 @@ Objects/unicodeobject.c	unicode_translate_call_errorhandler	argparse	-
 Parser/parser.c	-	reserved_keywords	-
 Parser/parser.c	-	soft_keywords	-
 Parser/lexer/lexer.c	-	type_comment_prefix	-
-Python/ast_opt.c	fold_unaryop	ops	-
 Python/ceval.c	-	_PyEval_BinaryOps	-
 Python/ceval.c	-	_Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS	-
 Python/codecs.c	-	Py_hexdigits	-
+Python/codecs.c	-	codecs_builtin_error_handlers	-
 Python/codecs.c	-	ucnhash_capi	-
 Python/codecs.c	_PyCodec_InitRegistry	methods	-
-Python/compile.c	-	NO_LABEL	-
 Python/compile.c	-	NO_LOCATION	-
 Python/dynload_shlib.c	-	_PyImport_DynLoadFiletab	-
 Python/dynload_stub.c	-	_PyImport_DynLoadFiletab	-
@@ -376,28 +385,21 @@ Python/pylifecycle.c	-	INTERPRETER_TRAMPOLINE_CODEDEF	-
 Python/pystate.c	-	initial	-
 Python/specialize.c	-	adaptive_opcodes	-
 Python/specialize.c	-	cache_requirements	-
+Python/specialize.c	-	binaryop_extend_descrs	-
 Python/stdlib_module_names.h	-	_Py_stdlib_module_names	-
 Python/sysmodule.c	-	perf_map_state	-
 Python/sysmodule.c	-	_PySys_ImplCacheTag	-
 Python/sysmodule.c	-	_PySys_ImplName	-
 Python/sysmodule.c	-	whatstrings	-
-Python/optimizer.c	-	_PyDefaultOptimizer_Type	-
-Python/optimizer.c	-	_PyCounterExecutor_Type	-
-Python/optimizer.c	-	_PyCounterOptimizer_Type	-
 Python/optimizer.c	-	_PyUOpExecutor_Type	-
-Python/optimizer.c	-	_PyUOpOptimizer_Type	-
 Python/optimizer.c	-	_PyOptimizer_Default	-
 Python/optimizer.c	-	_ColdExit_Type	-
-Python/optimizer.c	-	COLD_EXITS	-
 Python/optimizer.c	-	Py_FatalErrorExecutor	-
 Python/optimizer.c	-	EMPTY_FILTER	-
-Python/optimizer.c	-	cold_exits_initialized	-
 
 ##-----------------------
 ## test code
 
-Modules/_ctypes/_ctypes_test.c	-	_ctypes_test_slots	-
-Modules/_ctypes/_ctypes_test.c	-	_ctypes_testmodule	-
 Modules/_ctypes/_ctypes_test.c	-	_xxx_lib	-
 Modules/_ctypes/_ctypes_test.c	-	an_integer	-
 Modules/_ctypes/_ctypes_test.c	-	bottom	-
@@ -405,7 +407,6 @@ Modules/_ctypes/_ctypes_test.c	-	last_tf_arg_s	-
 Modules/_ctypes/_ctypes_test.c	-	last_tf_arg_u	-
 Modules/_ctypes/_ctypes_test.c	-	last_tfrsuv_arg	-
 Modules/_ctypes/_ctypes_test.c	-	left	-
-Modules/_ctypes/_ctypes_test.c	-	module_methods	-
 Modules/_ctypes/_ctypes_test.c	-	my_eggs	-
 Modules/_ctypes/_ctypes_test.c	-	my_spams	-
 Modules/_ctypes/_ctypes_test.c	-	right	-
@@ -447,6 +448,8 @@ Modules/_testcapi/exceptions.c	-	PyRecursingInfinitelyError_Type	-
 Modules/_testcapi/heaptype.c	-	_testcapimodule	-
 Modules/_testcapi/mem.c	-	FmData	-
 Modules/_testcapi/mem.c	-	FmHook	-
+Modules/_testcapi/object.c	-	MyObject_dealloc_called	-
+Modules/_testcapi/object.c	-	MyType	-
 Modules/_testcapi/structmember.c	-	test_structmembersType_OldAPI	-
 Modules/_testcapi/watchers.c	-	g_dict_watch_events	-
 Modules/_testcapi/watchers.c	-	g_dict_watchers_installed	-
@@ -458,6 +461,9 @@ Modules/_testcapi/watchers.c	-	num_code_object_destroyed_events	-
 Modules/_testcapi/watchers.c	-	pyfunc_watchers	-
 Modules/_testcapi/watchers.c	-	func_watcher_ids	-
 Modules/_testcapi/watchers.c	-	func_watcher_callbacks	-
+Modules/_testcapi/watchers.c	-	context_watcher_ids	-
+Modules/_testcapi/watchers.c	-	context_switches	-
+Modules/_testcapi/watchers.c	add_context_watcher	callbacks	-
 Modules/_testcapimodule.c	-	BasicStaticTypes	-
 Modules/_testcapimodule.c	-	num_basic_static_types_used	-
 Modules/_testcapimodule.c	-	ContainerNoGC_members	-
@@ -630,8 +636,6 @@ Modules/_xxtestfuzz/fuzzer.c	LLVMFuzzerTestOneInput	ELEMENTTREE_PARSEWHOLE_INITI
 Include/internal/pycore_importdl.h	-	_PyImport_DynLoadFiletab	-
 Include/py_curses.h	-	PyCurses_API	-
 Include/pydecimal.h	-	_decimal_api	-
-Modules/_blake2/blake2module.c	-	blake2b_type_spec	-
-Modules/_blake2/blake2module.c	-	blake2s_type_spec	-
 Modules/_io/fileio.c	-	_Py_open_cloexec_works	-
 Modules/_io/_iomodule.h	-	PyIOBase_Type	-
 Modules/_io/_iomodule.h	-	PyRawIOBase_Type	-
@@ -742,10 +746,14 @@ Modules/expat/xmlrole.c	-	declClose	-
 Modules/expat/xmlrole.c	-	error	-
 
 ## other
-Modules/grpmodule.c	grp_getgrall_impl	getgrall_mutex	-
 Modules/_io/_iomodule.c	-	_PyIO_Module	-
 Modules/_sqlite/module.c	-	_sqlite3module	-
+Modules/_zstd/_zstdmodule.c	-	_zstdmodule	-
 Modules/clinic/md5module.c.h	_md5_md5	_keywords	-
 Modules/clinic/grpmodule.c.h	grp_getgrgid	_keywords	-
 Modules/clinic/grpmodule.c.h	grp_getgrnam	_keywords	-
 Objects/object.c	-	constants	static PyObject*[]
+
+
+## False positives
+Python/specialize.c	-	_Py_InitCleanup	-
diff --git a/Tools/clinic/.ruff.toml b/Tools/clinic/.ruff.toml
index c019572..5033887 100644
--- a/Tools/clinic/.ruff.toml
+++ b/Tools/clinic/.ruff.toml
@@ -1,5 +1,4 @@
-target-version = "py310"
-fix = true
+extend = "../../.ruff.toml"  # Inherit the project-wide settings
 
 [lint]
 select = [
diff --git a/Tools/clinic/libclinic/clanguage.py b/Tools/clinic/libclinic/clanguage.py
index 73d4783..9e7fa7a 100644
--- a/Tools/clinic/libclinic/clanguage.py
+++ b/Tools/clinic/libclinic/clanguage.py
@@ -404,9 +404,6 @@ def render_function(
             if (i != -1) and (p.default is not unspecified):
                 first_optional = min(first_optional, i)
 
-            if p.is_vararg():
-                data.cleanup.append(f"Py_XDECREF({c.parser_name});")
-
             # insert group variable
             group = p.group
             if last_group != group:
@@ -426,14 +423,14 @@ def render_function(
 
         # HACK
         # when we're METH_O, but have a custom return converter,
-        # we use "impl_parameters" for the parsing function
+        # we use "parser_parameters" for the parsing function
         # because that works better.  but that means we must
         # suppress actually declaring the impl's parameters
         # as variables in the parsing function.  but since it's
         # METH_O, we have exactly one anyway, so we know exactly
         # where it is.
         if ("METH_O" in templates['methoddef_define'] and
-            '{impl_parameters}' in templates['parser_prototype']):
+            '{parser_parameters}' in templates['parser_prototype']):
             data.declarations.pop(0)
 
         full_name = f.full_name
@@ -478,6 +475,7 @@ def render_function(
         else:
             template_dict['parse_arguments_comma'] = '';
         template_dict['impl_parameters'] = ", ".join(data.impl_parameters)
+        template_dict['parser_parameters'] = ", ".join(data.impl_parameters[1:])
         template_dict['impl_arguments'] = ", ".join(data.impl_arguments)
 
         template_dict['return_conversion'] = libclinic.format_escape("".join(data.return_conversion).rstrip())
diff --git a/Tools/clinic/libclinic/converter.py b/Tools/clinic/libclinic/converter.py
index 86853bb..2c93dda 100644
--- a/Tools/clinic/libclinic/converter.py
+++ b/Tools/clinic/libclinic/converter.py
@@ -312,7 +312,7 @@ def render(self, parameter: Parameter, data: CRenderData) -> None:
     def length_name(self) -> str:
         """Computes the name of the associated "length" variable."""
         assert self.length is not None
-        return self.parser_name + "_length"
+        return self.name + "_length"
 
     # Why is this one broken out separately?
     # For "positional-only" function parsing,
diff --git a/Tools/clinic/libclinic/converters.py b/Tools/clinic/libclinic/converters.py
index 978bd94..39d0ac5 100644
--- a/Tools/clinic/libclinic/converters.py
+++ b/Tools/clinic/libclinic/converters.py
@@ -17,6 +17,54 @@
 TypeSet = set[bltns.type[object]]
 
 
+class BaseUnsignedIntConverter(CConverter):
+
+    def use_converter(self) -> None:
+        if self.converter:
+            self.add_include('pycore_long.h',
+                             f'{self.converter}()')
+
+    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+        if not limited_capi:
+            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return self.format_code("""
+            {{{{
+                Py_ssize_t _bytes = PyLong_AsNativeBytes({argname}, &{paramname}, sizeof({type}),
+                        Py_ASNATIVEBYTES_NATIVE_ENDIAN |
+                        Py_ASNATIVEBYTES_ALLOW_INDEX |
+                        Py_ASNATIVEBYTES_REJECT_NEGATIVE |
+                        Py_ASNATIVEBYTES_UNSIGNED_BUFFER);
+                if (_bytes < 0) {{{{
+                    goto exit;
+                }}}}
+                if ((size_t)_bytes > sizeof({type})) {{{{
+                    PyErr_SetString(PyExc_OverflowError,
+                                    "Python int too large for C {type}");
+                    goto exit;
+                }}}}
+            }}}}
+            """,
+            argname=argname,
+            type=self.type)
+
+
+class uint8_converter(BaseUnsignedIntConverter):
+    type = "uint8_t"
+    converter = '_PyLong_UInt8_Converter'
+
+class uint16_converter(BaseUnsignedIntConverter):
+    type = "uint16_t"
+    converter = '_PyLong_UInt16_Converter'
+
+class uint32_converter(BaseUnsignedIntConverter):
+    type = "uint32_t"
+    converter = '_PyLong_UInt32_Converter'
+
+class uint64_converter(BaseUnsignedIntConverter):
+    type = "uint64_t"
+    converter = '_PyLong_UInt64_Converter'
+
+
 class bool_converter(CConverter):
     type = 'int'
     default_type = bool
@@ -61,6 +109,7 @@ class defining_class_converter(CConverter):
     type = 'PyTypeObject *'
     format_unit = ''
     show_in_signature = False
+    specified_type: str | None = None
 
     def converter_init(self, *, type: str | None = None) -> None:
         self.specified_type = type
@@ -90,10 +139,24 @@ def converter_init(self) -> None:
     def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
         if self.format_unit == 'c':
             return self.format_code("""
-                if (PyBytes_Check({argname}) && PyBytes_GET_SIZE({argname}) == 1) {{{{
+                if (PyBytes_Check({argname})) {{{{
+                    if (PyBytes_GET_SIZE({argname}) != 1) {{{{
+                        PyErr_Format(PyExc_TypeError,
+                            "{{name}}(): {displayname} must be a byte string of length 1, "
+                            "not a bytes object of length %zd",
+                            PyBytes_GET_SIZE({argname}));
+                        goto exit;
+                    }}}}
                     {paramname} = PyBytes_AS_STRING({argname})[0];
                 }}}}
-                else if (PyByteArray_Check({argname}) && PyByteArray_GET_SIZE({argname}) == 1) {{{{
+                else if (PyByteArray_Check({argname})) {{{{
+                    if (PyByteArray_GET_SIZE({argname}) != 1) {{{{
+                        PyErr_Format(PyExc_TypeError,
+                            "{{name}}(): {displayname} must be a byte string of length 1, "
+                            "not a bytearray object of length %zd",
+                            PyByteArray_GET_SIZE({argname}));
+                        goto exit;
+                    }}}}
                     {paramname} = PyByteArray_AS_STRING({argname})[0];
                 }}}}
                 else {{{{
@@ -102,6 +165,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname,
+                displayname=displayname,
                 bad_argument=self.bad_argument(displayname, 'a byte string of length 1', limited_capi=limited_capi),
             )
         return super().parse_arg(argname, displayname, limited_capi=limited_capi)
@@ -195,7 +259,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
         return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
-class unsigned_short_converter(CConverter):
+class unsigned_short_converter(BaseUnsignedIntConverter):
     type = 'unsigned short'
     default_type = int
     c_ignored_default = "0"
@@ -206,11 +270,6 @@ def converter_init(self, *, bitwise: bool = False) -> None:
         else:
             self.converter = '_PyLong_UnsignedShort_Converter'
 
-    def use_converter(self) -> None:
-        if self.converter == '_PyLong_UnsignedShort_Converter':
-            self.add_include('pycore_long.h',
-                             '_PyLong_UnsignedShort_Converter()')
-
     def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
         if self.format_unit == 'H':
             return self.format_code("""
@@ -220,24 +279,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
-        # NOTE: Raises OverflowError for negative integer.
-        return self.format_code("""
-            {{{{
-                unsigned long uval = PyLong_AsUnsignedLong({argname});
-                if (uval == (unsigned long)-1 && PyErr_Occurred()) {{{{
-                    goto exit;
-                }}}}
-                if (uval > USHRT_MAX) {{{{
-                    PyErr_SetString(PyExc_OverflowError,
-                                    "Python int too large for C unsigned short");
-                    goto exit;
-                }}}}
-                {paramname} = (unsigned short) uval;
-            }}}}
-            """,
-            argname=argname)
+        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
 @add_legacy_c_converter('C', accept={str})
@@ -273,18 +315,22 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                     goto exit;
                 }}}}
                 if (PyUnicode_GET_LENGTH({argname}) != 1) {{{{
-                    {bad_argument}
+                    PyErr_Format(PyExc_TypeError,
+                        "{{name}}(): {displayname} must be a unicode character, "
+                        "not a string of length %zd",
+                        PyUnicode_GET_LENGTH({argname}));
                     goto exit;
                 }}}}
                 {paramname} = PyUnicode_READ_CHAR({argname}, 0);
                 """,
                 argname=argname,
+                displayname=displayname,
                 bad_argument=self.bad_argument(displayname, 'a unicode character', limited_capi=limited_capi),
             )
         return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
-class unsigned_int_converter(CConverter):
+class unsigned_int_converter(BaseUnsignedIntConverter):
     type = 'unsigned int'
     default_type = int
     c_ignored_default = "0"
@@ -295,11 +341,6 @@ def converter_init(self, *, bitwise: bool = False) -> None:
         else:
             self.converter = '_PyLong_UnsignedInt_Converter'
 
-    def use_converter(self) -> None:
-        if self.converter == '_PyLong_UnsignedInt_Converter':
-            self.add_include('pycore_long.h',
-                             '_PyLong_UnsignedInt_Converter()')
-
     def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
         if self.format_unit == 'I':
             return self.format_code("""
@@ -309,24 +350,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
-        # NOTE: Raises OverflowError for negative integer.
-        return self.format_code("""
-            {{{{
-                unsigned long uval = PyLong_AsUnsignedLong({argname});
-                if (uval == (unsigned long)-1 && PyErr_Occurred()) {{{{
-                    goto exit;
-                }}}}
-                if (uval > UINT_MAX) {{{{
-                    PyErr_SetString(PyExc_OverflowError,
-                                    "Python int too large for C unsigned int");
-                    goto exit;
-                }}}}
-                {paramname} = (unsigned int) uval;
-            }}}}
-            """,
-            argname=argname)
+        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
 class long_converter(CConverter):
@@ -347,7 +371,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
         return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
-class unsigned_long_converter(CConverter):
+class unsigned_long_converter(BaseUnsignedIntConverter):
     type = 'unsigned long'
     default_type = int
     c_ignored_default = "0"
@@ -358,15 +382,10 @@ def converter_init(self, *, bitwise: bool = False) -> None:
         else:
             self.converter = '_PyLong_UnsignedLong_Converter'
 
-    def use_converter(self) -> None:
-        if self.converter == '_PyLong_UnsignedLong_Converter':
-            self.add_include('pycore_long.h',
-                             '_PyLong_UnsignedLong_Converter()')
-
     def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
         if self.format_unit == 'k':
             return self.format_code("""
-                if (!PyLong_Check({argname})) {{{{
+                if (!PyIndex_Check({argname})) {{{{
                     {bad_argument}
                     goto exit;
                 }}}}
@@ -375,16 +394,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 argname=argname,
                 bad_argument=self.bad_argument(displayname, 'int', limited_capi=limited_capi),
             )
-        if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
-        # NOTE: Raises OverflowError for negative integer.
-        return self.format_code("""
-            {paramname} = PyLong_AsUnsignedLong({argname});
-            if ({paramname} == (unsigned long)-1 && PyErr_Occurred()) {{{{
-                goto exit;
-            }}}}
-            """,
-            argname=argname)
+        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
 class long_long_converter(CConverter):
@@ -405,7 +415,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
         return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
-class unsigned_long_long_converter(CConverter):
+class unsigned_long_long_converter(BaseUnsignedIntConverter):
     type = 'unsigned long long'
     default_type = int
     c_ignored_default = "0"
@@ -416,15 +426,10 @@ def converter_init(self, *, bitwise: bool = False) -> None:
         else:
             self.converter = '_PyLong_UnsignedLongLong_Converter'
 
-    def use_converter(self) -> None:
-        if self.converter == '_PyLong_UnsignedLongLong_Converter':
-            self.add_include('pycore_long.h',
-                             '_PyLong_UnsignedLongLong_Converter()')
-
     def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
         if self.format_unit == 'K':
             return self.format_code("""
-                if (!PyLong_Check({argname})) {{{{
+                if (!PyIndex_Check({argname})) {{{{
                     {bad_argument}
                     goto exit;
                 }}}}
@@ -433,16 +438,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 argname=argname,
                 bad_argument=self.bad_argument(displayname, 'int', limited_capi=limited_capi),
             )
-        if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
-        # NOTE: Raises OverflowError for negative integer.
-        return self.format_code("""
-            {paramname} = PyLong_AsUnsignedLongLong({argname});
-            if ({paramname} == (unsigned long long)-1 && PyErr_Occurred()) {{{{
-                goto exit;
-            }}}}
-            """,
-            argname=argname)
+        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
 class Py_ssize_t_converter(CConverter):
@@ -559,15 +555,11 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 argname=argname)
 
 
-class size_t_converter(CConverter):
+class size_t_converter(BaseUnsignedIntConverter):
     type = 'size_t'
     converter = '_PyLong_Size_t_Converter'
     c_ignored_default = "0"
 
-    def use_converter(self) -> None:
-        self.add_include('pycore_long.h',
-                         '_PyLong_Size_t_Converter()')
-
     def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
         if self.format_unit == 'n':
             return self.format_code("""
@@ -577,16 +569,7 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
-        # NOTE: Raises OverflowError for negative integer.
-        return self.format_code("""
-            {paramname} = PyLong_AsSize_t({argname});
-            if ({paramname} == (size_t)-1 && PyErr_Occurred()) {{{{
-                goto exit;
-            }}}}
-            """,
-            argname=argname)
+        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
 
 
 class fildes_converter(CConverter):
@@ -1088,15 +1071,24 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
 
 
 def correct_name_for_self(
-        f: Function
+        f: Function,
+        parser: bool = False
 ) -> tuple[str, str]:
     if f.kind in {CALLABLE, METHOD_INIT, GETTER, SETTER}:
         if f.cls:
             return "PyObject *", "self"
         return "PyObject *", "module"
     if f.kind is STATIC_METHOD:
-        return "void *", "null"
-    if f.kind in (CLASS_METHOD, METHOD_NEW):
+        if parser:
+            return "PyObject *", "null"
+        else:
+            return "void *", "null"
+    if f.kind == CLASS_METHOD:
+        if parser:
+            return "PyObject *", "type"
+        else:
+            return "PyTypeObject *", "type"
+    if f.kind == METHOD_NEW:
         return "PyTypeObject *", "type"
     raise AssertionError(f"Unhandled type of function f: {f.kind!r}")
 
@@ -1108,6 +1100,7 @@ class self_converter(CConverter):
     """
     type: str | None = None
     format_unit = ''
+    specified_type: str | None = None
 
     def converter_init(self, *, type: str | None = None) -> None:
         self.specified_type = type
@@ -1164,10 +1157,8 @@ def pre_render(self) -> None:
     @property
     def parser_type(self) -> str:
         assert self.type is not None
-        if self.function.kind in {METHOD_INIT, METHOD_NEW, STATIC_METHOD, CLASS_METHOD}:
-            tp, _ = correct_name_for_self(self.function)
-            return tp
-        return self.type
+        tp, _ = correct_name_for_self(self.function, parser=True)
+        return tp
 
     def render(self, parameter: Parameter, data: CRenderData) -> None:
         """
@@ -1210,3 +1201,106 @@ def set_template_dict(self, template_dict: TemplateDict) -> None:
             type_object = cls.type_object
             type_ptr = f'PyTypeObject *base_tp = {type_object};'
             template_dict['base_type_ptr'] = type_ptr
+
+    def use_pyobject_self(self, func: Function) -> bool:
+        conv_type = self.type
+        if conv_type is None:
+            conv_type, _ = correct_name_for_self(func)
+        return (conv_type in ('PyObject *', None)
+                and self.specified_type in ('PyObject *', None))
+
+
+# Converters for var-positional parameter.
+
+class VarPosCConverter(CConverter):
+    format_unit = ''
+
+    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+        raise AssertionError('should never be called')
+
+    def parse_vararg(self, *, pos_only: int, min_pos: int, max_pos: int,
+                     fastcall: bool, limited_capi: bool) -> str:
+        raise NotImplementedError
+
+
+class varpos_tuple_converter(VarPosCConverter):
+    type = 'PyObject *'
+    format_unit = ''
+    c_default = 'NULL'
+
+    def cleanup(self) -> str:
+        return f"""Py_XDECREF({self.parser_name});\n"""
+
+    def parse_vararg(self, *, pos_only: int, min_pos: int, max_pos: int,
+                     fastcall: bool, limited_capi: bool) -> str:
+        paramname = self.parser_name
+        if fastcall:
+            if limited_capi:
+                if min(pos_only, min_pos) < max_pos:
+                    size = f'Py_MAX(nargs - {max_pos}, 0)'
+                else:
+                    size = f'nargs - {max_pos}' if max_pos else 'nargs'
+                return f"""
+                    {paramname} = PyTuple_New({size});
+                    if (!{paramname}) {{{{
+                        goto exit;
+                    }}}}
+                    for (Py_ssize_t i = {max_pos}; i < nargs; ++i) {{{{
+                        PyTuple_SET_ITEM({paramname}, i - {max_pos}, Py_NewRef(args[i]));
+                    }}}}
+                    """
+            else:
+                self.add_include('pycore_tuple.h', '_PyTuple_FromArray()')
+                start = f'args + {max_pos}' if max_pos else 'args'
+                size = f'nargs - {max_pos}' if max_pos else 'nargs'
+                if min(pos_only, min_pos) < max_pos:
+                    return f"""
+                        {paramname} = nargs > {max_pos}
+                            ? _PyTuple_FromArray({start}, {size})
+                            : PyTuple_New(0);
+                        if ({paramname} == NULL) {{{{
+                            goto exit;
+                        }}}}
+                        """
+                else:
+                    return f"""
+                        {paramname} = _PyTuple_FromArray({start}, {size});
+                        if ({paramname} == NULL) {{{{
+                            goto exit;
+                        }}}}
+                        """
+        else:
+            if max_pos:
+                return f"""
+                    {paramname} = PyTuple_GetSlice(args, {max_pos}, PY_SSIZE_T_MAX);
+                    if (!{paramname}) {{{{
+                        goto exit;
+                    }}}}
+                    """
+            else:
+                return f"{paramname} = Py_NewRef(args);\n"
+
+
+class varpos_array_converter(VarPosCConverter):
+    type = 'PyObject * const *'
+    length = True
+    c_ignored_default = ''
+
+    def parse_vararg(self, *, pos_only: int, min_pos: int, max_pos: int,
+                     fastcall: bool, limited_capi: bool) -> str:
+        paramname = self.parser_name
+        if not fastcall:
+            self.add_include('pycore_tuple.h', '_PyTuple_ITEMS()')
+        start = 'args' if fastcall else '_PyTuple_ITEMS(args)'
+        size = 'nargs' if fastcall else 'PyTuple_GET_SIZE(args)'
+        if max_pos:
+            if min(pos_only, min_pos) < max_pos:
+                start = f'{size} > {max_pos} ? {start} + {max_pos} : {start}'
+                size = f'Py_MAX(0, {size} - {max_pos})'
+            else:
+                start = f'{start} + {max_pos}'
+                size = f'{size} - {max_pos}'
+        return f"""
+            {paramname} = {start};
+            {self.length_name} = {size};
+            """
diff --git a/Tools/clinic/libclinic/dsl_parser.py b/Tools/clinic/libclinic/dsl_parser.py
index 27c0421..eca4153 100644
--- a/Tools/clinic/libclinic/dsl_parser.py
+++ b/Tools/clinic/libclinic/dsl_parser.py
@@ -119,7 +119,7 @@ class ParamState(enum.IntEnum):
     # Legal transitions: to LEFT_SQUARE_BEFORE or REQUIRED
     START = 0
 
-    # Left square backets before required params.
+    # Left square brackets before required params.
     LEFT_SQUARE_BEFORE = 1
 
     # In a group, before required params.
@@ -260,6 +260,7 @@ class DSLParser:
     preserve_output: bool
     critical_section: bool
     target_critical_section: list[str]
+    disable_fastcall: bool
     from_version_re = re.compile(r'([*/]) +\[from +(.+)\]')
 
     def __init__(self, clinic: Clinic) -> None:
@@ -296,6 +297,7 @@ def reset(self) -> None:
         self.preserve_output = False
         self.critical_section = False
         self.target_critical_section = []
+        self.disable_fastcall = False
 
     def directive_module(self, name: str) -> None:
         fields = name.split('.')[:-1]
@@ -423,6 +425,18 @@ def at_critical_section(self, *args: str) -> None:
         self.target_critical_section.extend(args)
         self.critical_section = True
 
+    def at_disable(self, *args: str) -> None:
+        if self.kind is not CALLABLE:
+            fail("Can't set @disable, function is not a normal callable")
+        if not args:
+            fail("@disable expects at least one argument")
+        features = list(args)
+        if 'fastcall' in features:
+            features.remove('fastcall')
+            self.disable_fastcall = True
+        if features:
+            fail("invalid argument for @disable:", features[0])
+
     def at_getter(self) -> None:
         match self.kind:
             case FunctionKind.GETTER:
@@ -691,6 +705,7 @@ def state_modulename_name(self, line: str) -> None:
             kind=self.kind,
             coexist=self.coexist,
             critical_section=self.critical_section,
+            disable_fastcall=self.disable_fastcall,
             target_critical_section=self.target_critical_section,
             forced_text_signature=self.forced_text_signature
         )
@@ -862,43 +877,16 @@ def parse_parameter(self, line: str) -> None:
 
         # handle "as" for  parameters too
         c_name = None
-        name, have_as_token, trailing = line.partition(' as ')
-        if have_as_token:
-            name = name.strip()
-            if ' ' not in name:
-                fields = trailing.strip().split(' ')
-                if not fields:
-                    fail("Invalid 'as' clause!")
-                c_name = fields[0]
-                if c_name.endswith(':'):
-                    name += ':'
-                    c_name = c_name[:-1]
-                fields[0] = name
-                line = ' '.join(fields)
-
-        default: str | None
-        base, equals, default = line.rpartition('=')
-        if not equals:
-            base = default
-            default = None
-
-        module = None
+        m = re.match(r'(?:\* *)?\w+( +as +(\w+))', line)
+        if m:
+            c_name = m[2]
+            line = line[:m.start(1)] + line[m.end(1):]
+
         try:
-            ast_input = f"def x({base}): pass"
+            ast_input = f"def x({line}\n): pass"
             module = ast.parse(ast_input)
         except SyntaxError:
-            try:
-                # the last = was probably inside a function call, like
-                #   c: int(accept={str})
-                # so assume there was no actual default value.
-                default = None
-                ast_input = f"def x({line}): pass"
-                module = ast.parse(ast_input)
-            except SyntaxError:
-                pass
-        if not module:
-            fail(f"Function {self.function.name!r} has an invalid parameter declaration:\n\t",
-                 repr(line))
+            fail(f"Function {self.function.name!r} has an invalid parameter declaration: {line!r}")
 
         function = module.body[0]
         assert isinstance(function, ast.FunctionDef)
@@ -907,9 +895,6 @@ def parse_parameter(self, line: str) -> None:
         if len(function_args.args) > 1:
             fail(f"Function {self.function.name!r} has an "
                  f"invalid parameter declaration (comma?): {line!r}")
-        if function_args.defaults or function_args.kw_defaults:
-            fail(f"Function {self.function.name!r} has an "
-                 f"invalid parameter declaration (default value?): {line!r}")
         if function_args.kwarg:
             fail(f"Function {self.function.name!r} has an "
                  f"invalid parameter declaration (**kwargs?): {line!r}")
@@ -925,31 +910,28 @@ def parse_parameter(self, line: str) -> None:
 
         parameter_name = parameter.arg
         name, legacy, kwargs = self.parse_converter(parameter.annotation)
+        if is_vararg:
+            name = 'varpos_' + name
 
         value: object
-        if not default:
-            if self.parameter_state is ParamState.OPTIONAL:
-                fail(f"Can't have a parameter without a default ({parameter_name!r}) "
-                      "after a parameter with a default!")
+        if not function_args.defaults:
             if is_vararg:
                 value = NULL
-                kwargs.setdefault('c_default', "NULL")
             else:
+                if self.parameter_state is ParamState.OPTIONAL:
+                    fail(f"Can't have a parameter without a default ({parameter_name!r}) "
+                          "after a parameter with a default!")
                 value = unspecified
             if 'py_default' in kwargs:
                 fail("You can't specify py_default without specifying a default value!")
         else:
-            if is_vararg:
-                fail("Vararg can't take a default value!")
+            expr = function_args.defaults[0]
+            default = ast_input[expr.col_offset: expr.end_col_offset].strip()
 
             if self.parameter_state is ParamState.REQUIRED:
                 self.parameter_state = ParamState.OPTIONAL
-            default = default.strip()
             bad = False
-            ast_input = f"x = {default}"
             try:
-                module = ast.parse(ast_input)
-
                 if 'c_default' not in kwargs:
                     # we can only represent very simple data values in C.
                     # detect whether default is okay, via a denylist
@@ -976,13 +958,14 @@ def bad_node(self, node: ast.AST) -> None:
                         visit_Starred = bad_node
 
                     denylist = DetectBadNodes()
-                    denylist.visit(module)
+                    denylist.visit(expr)
                     bad = denylist.bad
                 else:
                     # if they specify a c_default, we can be more lenient about the default value.
                     # but at least make an attempt at ensuring it's a valid expression.
+                    code = compile(ast.Expression(expr), '<expr>', 'eval')
                     try:
-                        value = eval(default)
+                        value = eval(code)
                     except NameError:
                         pass # probably a named constant
                     except Exception as e:
@@ -994,9 +977,6 @@ def bad_node(self, node: ast.AST) -> None:
                 if bad:
                     fail(f"Unsupported expression as default value: {default!r}")
 
-                assignment = module.body[0]
-                assert isinstance(assignment, ast.Assign)
-                expr = assignment.value
                 # mild hack: explicitly support NULL as a default value
                 c_default: str | None
                 if isinstance(expr, ast.Name) and expr.id == 'NULL':
@@ -1048,8 +1028,6 @@ def bad_node(self, node: ast.AST) -> None:
                     else:
                         c_default = py_default
 
-            except SyntaxError as e:
-                fail(f"Syntax error: {e.text!r}")
             except (ValueError, AttributeError):
                 value = unknown
                 c_default = kwargs.get("c_default")
diff --git a/Tools/clinic/libclinic/function.py b/Tools/clinic/libclinic/function.py
index 9390126..e80e2f5 100644
--- a/Tools/clinic/libclinic/function.py
+++ b/Tools/clinic/libclinic/function.py
@@ -109,6 +109,7 @@ class Function:
     docstring_only: bool = False
     forced_text_signature: str | None = None
     critical_section: bool = False
+    disable_fastcall: bool = False
     target_critical_section: list[str] = dc.field(default_factory=list)
 
     def __post_init__(self) -> None:
diff --git a/Tools/clinic/libclinic/parse_args.py b/Tools/clinic/libclinic/parse_args.py
index 1e6ebdd..0e15d2f 100644
--- a/Tools/clinic/libclinic/parse_args.py
+++ b/Tools/clinic/libclinic/parse_args.py
@@ -65,9 +65,11 @@ def declare_parser(
             static struct {{
                 PyGC_Head _this_is_not_used;
                 PyObject_VAR_HEAD
+                Py_hash_t ob_hash;
                 PyObject *ob_item[NUM_KEYWORDS];
             }} _kwtuple = {{
                 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+                .ob_hash = -1,
                 .ob_item = {{ {keywords_py} }},
             }};
             #undef NUM_KEYWORDS
@@ -134,7 +136,7 @@ def declare_parser(
 """)
 METH_O_PROTOTYPE: Final[str] = libclinic.normalize_snippet("""
     static PyObject *
-    {c_basename}({impl_parameters})
+    {c_basename}({self_type}{self_name}, {parser_parameters})
 """)
 DOCSTRING_PROTOTYPE_VAR: Final[str] = libclinic.normalize_snippet("""
     PyDoc_VAR({c_basename}__doc__);
@@ -195,6 +197,7 @@ class ParseArgsCodeGen:
 
     # Function parameters
     parameters: list[Parameter]
+    self_parameter_converter: self_converter
     converters: list[CConverter]
 
     # Is 'defining_class' used for the first parameter?
@@ -216,8 +219,7 @@ class ParseArgsCodeGen:
     min_pos: int = 0
     max_pos: int = 0
     min_kw_only: int = 0
-    pseudo_args: int = 0
-    vararg: int | str = NO_VARARG
+    varpos: Parameter | None = None
 
     docstring_prototype: str
     docstring_definition: str
@@ -237,37 +239,43 @@ def __init__(self, func: Function, codegen: CodeGen) -> None:
         self.codegen = codegen
 
         self.parameters = list(self.func.parameters.values())
-        first_param = self.parameters.pop(0)
-        if not isinstance(first_param.converter, self_converter):
+        self_parameter = self.parameters.pop(0)
+        if not isinstance(self_parameter.converter, self_converter):
             raise ValueError("the first parameter must use self_converter")
+        self.self_parameter_converter = self_parameter.converter
 
         self.requires_defining_class = False
         if self.parameters and isinstance(self.parameters[0].converter, defining_class_converter):
             self.requires_defining_class = True
             del self.parameters[0]
+
+        for i, p in enumerate(self.parameters):
+            if p.is_vararg():
+                self.varpos = p
+                del self.parameters[i]
+                break
+
         self.converters = [p.converter for p in self.parameters]
 
         if self.func.critical_section:
             self.codegen.add_include('pycore_critical_section.h',
                                      'Py_BEGIN_CRITICAL_SECTION()')
-        self.fastcall = not self.is_new_or_init()
+        if self.func.disable_fastcall:
+            self.fastcall = False
+        else:
+            self.fastcall = not self.is_new_or_init()
 
         self.pos_only = 0
         self.min_pos = 0
         self.max_pos = 0
         self.min_kw_only = 0
-        self.pseudo_args = 0
         for i, p in enumerate(self.parameters, 1):
             if p.is_keyword_only():
                 assert not p.is_positional_only()
                 if not p.is_optional():
-                    self.min_kw_only = i - self.max_pos - int(self.vararg != NO_VARARG)
-            elif p.is_vararg():
-                self.pseudo_args += 1
-                self.vararg = i - 1
+                    self.min_kw_only = i - self.max_pos
             else:
-                if self.vararg == NO_VARARG:
-                    self.max_pos = i
+                self.max_pos = i
                 if p.is_positional_only():
                     self.pos_only = i
                 if not p.is_optional():
@@ -284,6 +292,7 @@ def use_meth_o(self) -> bool:
         return (len(self.parameters) == 1
                 and self.parameters[0].is_positional_only()
                 and not self.converters[0].is_optional()
+                and not self.varpos
                 and not self.requires_defining_class
                 and not self.is_new_or_init())
 
@@ -291,6 +300,9 @@ def use_simple_return(self) -> bool:
         return (self.func.return_converter.type == 'PyObject *'
                 and not self.func.critical_section)
 
+    def use_pyobject_self(self) -> bool:
+        return self.self_parameter_converter.use_pyobject_self(self.func)
+
     def select_prototypes(self) -> None:
         self.docstring_prototype = ''
         self.docstring_definition = ''
@@ -314,7 +326,8 @@ def select_prototypes(self) -> None:
 
     def init_limited_capi(self) -> None:
         self.limited_capi = self.codegen.limited_capi
-        if self.limited_capi and (self.pseudo_args or
+        if self.limited_capi and (
+                (self.varpos and self.pos_only < len(self.parameters)) or
                 (any(p.is_optional() for p in self.parameters) and
                  any(p.is_keyword_only() and not p.is_optional() for p in self.parameters)) or
                 any(c.broken_limited_capi for c in self.converters)):
@@ -400,7 +413,7 @@ def parse_one_arg(self) -> None:
             self.converters[0].format_unit == 'O'):
             meth_o_prototype = METH_O_PROTOTYPE
 
-            if self.use_simple_return():
+            if self.use_simple_return() and self.use_pyobject_self():
                 # maps perfectly to METH_O, doesn't need a return converter.
                 # so we skip making a parse function
                 # and call directly into the impl function.
@@ -446,6 +459,16 @@ def parse_option_groups(self) -> None:
         parser_code = '    {option_group_parsing}'
         self.parser_body(parser_code)
 
+    def _parse_vararg(self) -> str:
+        assert self.varpos is not None
+        c = self.varpos.converter
+        assert isinstance(c, libclinic.converters.VarPosCConverter)
+        return c.parse_vararg(pos_only=self.pos_only,
+                              min_pos=self.min_pos,
+                              max_pos=self.max_pos,
+                              fastcall=self.fastcall,
+                              limited_capi=self.limited_capi)
+
     def parse_pos_only(self) -> None:
         if self.fastcall:
             # positional-only, but no option groups
@@ -468,10 +491,9 @@ def parse_pos_only(self) -> None:
                 nargs = 'PyTuple_GET_SIZE(args)'
                 argname_fmt = 'PyTuple_GET_ITEM(args, %d)'
 
-        left_args = f"{nargs} - {self.max_pos}"
-        max_args = NO_VARARG if (self.vararg != NO_VARARG) else self.max_pos
+        parser_code = []
+        max_args = NO_VARARG if self.varpos else self.max_pos
         if self.limited_capi:
-            parser_code = []
             if nargs != 'nargs':
                 nargs_def = f'Py_ssize_t nargs = {nargs};'
                 parser_code.append(libclinic.normalize_snippet(nargs_def, indent=4))
@@ -504,50 +526,27 @@ def parse_pos_only(self) -> None:
                         }}}}
                         """,
                     indent=4))
-        else:
+        elif self.min_pos or max_args != NO_VARARG:
             self.codegen.add_include('pycore_modsupport.h',
                                      '_PyArg_CheckPositional()')
-            parser_code = [libclinic.normalize_snippet(f"""
+            parser_code.append(libclinic.normalize_snippet(f"""
                 if (!_PyArg_CheckPositional("{{name}}", {nargs}, {self.min_pos}, {max_args})) {{{{
                     goto exit;
                 }}}}
-                """, indent=4)]
+                """, indent=4))
 
         has_optional = False
         use_parser_code = True
         for i, p in enumerate(self.parameters):
-            if p.is_vararg():
-                if self.fastcall:
-                    parser_code.append(libclinic.normalize_snippet("""
-                        %s = PyTuple_New(%s);
-                        if (!%s) {{
-                            goto exit;
-                        }}
-                        for (Py_ssize_t i = 0; i < %s; ++i) {{
-                            PyTuple_SET_ITEM(%s, i, Py_NewRef(args[%d + i]));
-                        }}
-                        """ % (
-                            p.converter.parser_name,
-                            left_args,
-                            p.converter.parser_name,
-                            left_args,
-                            p.converter.parser_name,
-                            self.max_pos
-                        ), indent=4))
-                else:
-                    parser_code.append(libclinic.normalize_snippet("""
-                        %s = PyTuple_GetSlice(%d, -1);
-                        """ % (
-                            p.converter.parser_name,
-                            self.max_pos
-                        ), indent=4))
-                continue
-
             displayname = p.get_displayname(i+1)
             argname = argname_fmt % i
             parsearg: str | None
             parsearg = p.converter.parse_arg(argname, displayname, limited_capi=self.limited_capi)
             if parsearg is None:
+                if self.varpos:
+                    raise ValueError(
+                        f"Using converter {p.converter} is not supported "
+                        f"in function with var-positional parameter")
                 use_parser_code = False
                 parser_code = []
                 break
@@ -563,6 +562,8 @@ def parse_pos_only(self) -> None:
         if use_parser_code:
             if has_optional:
                 parser_code.append("skip_optional:")
+            if self.varpos:
+                parser_code.append(libclinic.normalize_snippet(self._parse_vararg(), indent=4))
         else:
             for parameter in self.parameters:
                 parameter.converter.use_converter()
@@ -601,7 +602,7 @@ def parse_general(self, clang: CLanguage) -> None:
 
         has_optional_kw = (
             max(self.pos_only, self.min_pos) + self.min_kw_only
-            < len(self.converters) - int(self.vararg != NO_VARARG)
+            < len(self.converters)
         )
 
         use_parser_code = True
@@ -610,57 +611,48 @@ def parse_general(self, clang: CLanguage) -> None:
             use_parser_code = False
             self.fastcall = False
         else:
-            if self.vararg == NO_VARARG:
-                self.codegen.add_include('pycore_modsupport.h',
-                                         '_PyArg_UnpackKeywords()')
-                args_declaration = "_PyArg_UnpackKeywords", "%s, %s, %s" % (
-                    self.min_pos,
-                    self.max_pos,
-                    self.min_kw_only
-                )
+            self.codegen.add_include('pycore_modsupport.h',
+                                     '_PyArg_UnpackKeywords()')
+            if not self.varpos:
                 nargs = "nargs"
             else:
-                self.codegen.add_include('pycore_modsupport.h',
-                                         '_PyArg_UnpackKeywordsWithVararg()')
-                args_declaration = "_PyArg_UnpackKeywordsWithVararg", "%s, %s, %s, %s" % (
-                    self.min_pos,
-                    self.max_pos,
-                    self.min_kw_only,
-                    self.vararg
-                )
                 nargs = f"Py_MIN(nargs, {self.max_pos})" if self.max_pos else "0"
 
             if self.fastcall:
                 self.flags = "METH_FASTCALL|METH_KEYWORDS"
                 self.parser_prototype = PARSER_PROTOTYPE_FASTCALL_KEYWORDS
-                argname_fmt = 'args[%d]'
                 self.declarations = declare_parser(self.func, codegen=self.codegen)
-                self.declarations += "\nPyObject *argsbuf[%s];" % len(self.converters)
+                self.declarations += "\nPyObject *argsbuf[%s];" % (len(self.converters) or 1)
+                if self.varpos:
+                    self.declarations += "\nPyObject * const *fastargs;"
+                    argsname = 'fastargs'
+                    argname_fmt = 'fastargs[%d]'
+                else:
+                    argsname = 'args'
+                    argname_fmt = 'args[%d]'
                 if has_optional_kw:
                     self.declarations += "\nPy_ssize_t noptargs = %s + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - %d;" % (nargs, self.min_pos + self.min_kw_only)
-                parser_code = [libclinic.normalize_snippet("""
-                    args = %s(args, nargs, NULL, kwnames, &_parser, %s, argsbuf);
-                    if (!args) {{
-                        goto exit;
-                    }}
-                    """ % args_declaration, indent=4)]
+                unpack_args = 'args, nargs, NULL, kwnames'
             else:
                 # positional-or-keyword arguments
                 self.flags = "METH_VARARGS|METH_KEYWORDS"
                 self.parser_prototype = PARSER_PROTOTYPE_KEYWORD
+                argsname = 'fastargs'
                 argname_fmt = 'fastargs[%d]'
                 self.declarations = declare_parser(self.func, codegen=self.codegen)
-                self.declarations += "\nPyObject *argsbuf[%s];" % len(self.converters)
+                self.declarations += "\nPyObject *argsbuf[%s];" % (len(self.converters) or 1)
                 self.declarations += "\nPyObject * const *fastargs;"
                 self.declarations += "\nPy_ssize_t nargs = PyTuple_GET_SIZE(args);"
                 if has_optional_kw:
                     self.declarations += "\nPy_ssize_t noptargs = %s + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - %d;" % (nargs, self.min_pos + self.min_kw_only)
-                parser_code = [libclinic.normalize_snippet("""
-                    fastargs = %s(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, %s, argsbuf);
-                    if (!fastargs) {{
-                        goto exit;
-                    }}
-                    """ % args_declaration, indent=4)]
+                unpack_args = '_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL'
+            parser_code = [libclinic.normalize_snippet(f"""
+                {argsname} = _PyArg_UnpackKeywords({unpack_args}, &_parser,
+                        /*minpos*/ {self.min_pos}, /*maxpos*/ {self.max_pos}, /*minkw*/ {self.min_kw_only}, /*varpos*/ {1 if self.varpos else 0}, argsbuf);
+                if (!{argsname}) {{{{
+                    goto exit;
+                }}}}
+                """, indent=4)]
 
         if self.requires_defining_class:
             self.flags = 'METH_METHOD|' + self.flags
@@ -709,8 +701,6 @@ def parse_general(self, clang: CLanguage) -> None:
                     else:
                         label = 'skip_optional_kwonly'
                         first_opt = self.max_pos + self.min_kw_only
-                        if self.vararg != NO_VARARG:
-                            first_opt += 1
                     if i == first_opt:
                         add_label = label
                         parser_code.append(libclinic.normalize_snippet("""
@@ -736,6 +726,8 @@ def parse_general(self, clang: CLanguage) -> None:
         if use_parser_code:
             if add_label:
                 parser_code.append("%s:" % add_label)
+            if self.varpos:
+                parser_code.append(libclinic.normalize_snippet(self._parse_vararg(), indent=4))
         else:
             for parameter in self.parameters:
                 parameter.converter.use_converter()
@@ -793,7 +785,10 @@ def parse_general(self, clang: CLanguage) -> None:
     def copy_includes(self) -> None:
         # Copy includes from parameters to Clinic after parse_arg()
         # has been called above.
-        for converter in self.converters:
+        converters = self.converters
+        if self.varpos:
+            converters = converters + [self.varpos.converter]
+        for converter in converters:
             for include in converter.get_includes():
                 self.codegen.add_include(
                     include.filename,
@@ -926,14 +921,14 @@ def parse_args(self, clang: CLanguage) -> dict[str, str]:
         # previous call to parser_body. this is used for an awful hack.
         self.parser_body_fields: tuple[str, ...] = ()
 
-        if not self.parameters:
+        if not self.parameters and not self.varpos:
             self.parse_no_args()
         elif self.use_meth_o():
             self.parse_one_arg()
         elif self.has_option_groups():
             self.parse_option_groups()
         elif (not self.requires_defining_class
-              and self.pos_only == len(self.parameters) - self.pseudo_args):
+              and self.pos_only == len(self.parameters)):
             self.parse_pos_only()
         else:
             self.parse_general(clang)