diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2c220d3..28ebe52 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -74,77 +74,85 @@ execute_process(
     OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 if(_python_platlib)
-    set(CPPINTEROP_INSTALL_DIR "${_python_platlib}/cppjit/cppyy_backend")
+    set(CPPINTEROP_INSTALL_DIR "${_python_platlib}/cppjit_backend")
 else()
-    set(CPPINTEROP_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/cppjit/cppyy_backend")
+    set(CPPINTEROP_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/cppjit_backend")
 endif()
 
 # Include cmake for CppInterOp config and build using ExternalProject.
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/AddCppInterOp.cmake)
 cppjit_add_cppinterop()
 
-# this libcppyy.so merges both CPyCppyy and clingwrapper
-file(GLOB CPYCPPYY_SOURCES CONFIGURE_DEPENDS src/CPyCppyy/src/*.cxx)
+# this libcppjit.so merges both cpyrt and the interop wrapper
+file(GLOB CPYRT_SOURCES CONFIGURE_DEPENDS src/cpyrt/*.cxx)
 set(BACKEND_SOURCES
-    src/backend/clingwrapper.cxx
+    src/backend/interop_wrapper.cxx
     src/backend/cppinterop_dispatch.cxx
 )
 
-add_library(cppyy SHARED ${CPYCPPYY_SOURCES} ${BACKEND_SOURCES})
-add_dependencies(cppyy CppInterOp)
+add_library(cppjit SHARED ${CPYRT_SOURCES} ${BACKEND_SOURCES})
+add_dependencies(cppjit CppInterOp)
 
 
-target_compile_definitions(cppyy PRIVATE
+target_compile_definitions(cppjit PRIVATE
     CPPINTEROP_DIR="${CPPINTEROP_INSTALL_DIR}"
     CMAKE_SHARED_LIBRARY_SUFFIX="${CMAKE_SHARED_LIBRARY_SUFFIX}"
 )
 
-target_include_directories(cppyy PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/CPyCppyy/include
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/CPyCppyy/src
+target_include_directories(cppjit PRIVATE
+    # src/ itself resolves the public "cpyrt/*.h" spellings against the
+    # flattened src/cpyrt/ directory
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/cpyrt
     ${CMAKE_CURRENT_SOURCE_DIR}/src/backend
     ${CPPINTEROP_INSTALL_DIR}/include
     ${Python_INCLUDE_DIRS}
 )
 
-target_compile_options(cppyy PRIVATE
+target_compile_options(cppjit PRIVATE
     -Wall -Wno-strict-aliasing -Wno-register
 )
 
 if(CMAKE_COMPILER_IS_GNUCXX)
-    target_link_options(cppyy PRIVATE -Wl,-Bsymbolic-functions)
+    target_link_options(cppjit PRIVATE -Wl,-Bsymbolic-functions)
 endif()
 
 # macOS needs to allow undefined Python symbols
 if(APPLE)
-    set_target_properties(cppyy PROPERTIES
+    set_target_properties(cppjit PROPERTIES
         LINK_FLAGS "-undefined dynamic_lookup"
         SUFFIX ".so"
     )
 endif()
 
-set_target_properties(cppyy PROPERTIES
-    OUTPUT_NAME "cppyy"
+set_target_properties(cppjit PROPERTIES
+    OUTPUT_NAME "cppjit"
     PREFIX "lib"
 )
 
-# libcppyy.so is installed in cppjit/ root (import cppjit.libcppyy)
-install(TARGETS cppyy
-    LIBRARY DESTINATION cppjit
+# libcppjit.so is installed at the site-packages root (import libcppjit)
+install(TARGETS cppjit
+    LIBRARY DESTINATION .
 )
 
 # install CppInterOp libraries and headers
 install(CODE "
     file(GLOB _interop_libs \"${CPPINTEROP_INSTALL_DIR}/lib/libclangCppInterOp*\")
     foreach(_lib \${_interop_libs})
-        file(INSTALL \${_lib} DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit/cppyy_backend/lib)
+        file(INSTALL \${_lib} DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit_backend/lib)
     endforeach()
 ")
 
 install(CODE "
-    file(INSTALL \"${CPPINTEROP_INSTALL_DIR}/include/\" DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit/cppyy_backend/include)
+    file(INSTALL \"${CPPINTEROP_INSTALL_DIR}/include/\" DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit_backend/include)
 ")
 
-install(DIRECTORY src/CPyCppyy/include/CPyCppyy
-    DESTINATION cppjit/cppyy_backend/include
+# the public cpyrt API headers keep their installed cpyrt/ prefix
+install(FILES
+    src/cpyrt/API.h
+    src/cpyrt/CommonDefs.h
+    src/cpyrt/DispatchPtr.h
+    src/cpyrt/PyException.h
+    src/cpyrt/Reflex.h
+    DESTINATION cppjit_backend/include/cpyrt
 )
diff --git a/pyproject.toml b/pyproject.toml
index ed91768..2aed137 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,7 +20,7 @@ authors = [
 
 [tool.scikit-build]
 wheel.install-dir = "."
-wheel.packages = ["python/cppjit"]
+wheel.packages = ["python/cppjit", "python/cppjit_backend"]
 cmake.build-type = "Release"
 
 [tool.pytest.ini_options]
diff --git a/python/cppjit/__init__.py b/python/cppjit/__init__.py
index fa2853e..1100fc5 100644
--- a/python/cppjit/__init__.py
+++ b/python/cppjit/__init__.py
@@ -1,2 +1,464 @@
-from .cppyy import *
-from .cppyy import gbl, _backend
+"""Dynamic C++ bindings generator.
+
+This module provides dynamic bindings to C++ through Cling, the LLVM-based C++
+interpreter, allowing interactive mixing of Python and C++. Example:
+
+    >>> import cppjit
+    >>> cppjit.cppdef(\"\"\"
+    ... class MyClass {
+    ... public:
+    ...     MyClass(int i) : m_data(i) {}
+    ...     int m_data;
+    ... };\"\"\")
+    True
+    >>> from cppjit.gbl import MyClass
+    >>> m = MyClass(42)
+    >>> cppjit.cppdef(\"\"\"
+    ... void say_hello(MyClass* m) {
+    ...     std::cout << "Hello, the number is: " << m->m_data << std::endl;
+    ... }\"\"\")
+    True
+    >>> MyClass.say_hello = cppjit.gbl.say_hello
+    >>> m.say_hello()
+    Hello, the number is: 42
+    >>> m.m_data = 13
+    >>> m.say_hello()
+    Hello, the number is: 13
+    >>>
+
+For full documentation, see:
+   https://cppyy.readthedocs.io/
+
+"""
+
+__author__ = 'Wim Lavrijsen <WLavrijsen@lbl.gov>'
+
+__all__ = [
+    'cppdef',                 # declare C++ source to Cling
+    'cppexec',                # execute a C++ statement
+    'macro',                  # attempt to evaluate a cpp macro
+    'include',                # load and jit a header file
+    'c_include',              # load and jit a C header file
+    'load_library',           # load a shared library
+    'nullptr',                # unique pointer representing NULL
+    'sizeof',                 # size of a C++ type
+    'typeid',                 # typeid of a C++ type
+    'multi',                  # helper for multiple inheritance
+    'add_include_path',       # add a path to search for headers
+    'add_library_path',       # add a path to search for libraries
+    'add_autoload_map',       # explicitly include an autoload map
+    'set_debug',              # enable/disable debug output
+    ]
+
+import ctypes, os, sys, sysconfig, warnings
+
+if not 'CLING_STANDARD_PCH' in os.environ:
+    def _set_pch():
+        try:
+            import cppjit_backend as cpb
+            local_pch = os.path.join(os.path.dirname(__file__), 'allDict.cxx.pch.'+str(cpb.__version__))
+            if os.path.exists(local_pch):
+                os.putenv('CLING_STANDARD_PCH', local_pch)
+                os.environ['CLING_STANDARD_PCH'] = local_pch
+        except (ImportError, AttributeError):
+            pass
+    _set_pch(); del _set_pch
+
+try:
+    import __pypy__
+    del __pypy__
+    ispypy = True
+except ImportError:
+    ispypy = False
+
+from . import _typemap
+from ._version import __version__
+
+# import separately instead of in the above try/except block for easier to
+# understand tracebacks
+if ispypy:
+    from ._pypy_cppjit import *
+else:
+    from ._cpython_cppjit import *
+
+
+#- allow importing from gbl --------------------------------------------------
+sys.modules['cppjit.gbl'] = gbl
+sys.modules['cppjit.gbl.std'] = gbl.std
+
+
+#- force creation of std.exception -------------------------------------------------------
+_e = gbl.std.exception
+
+
+#- enable auto-loading -------------------------------------------------------
+try:    gbl.cling.runtime.gCling.EnableAutoLoading()
+except: pass
+
+
+#- external typemap ----------------------------------------------------------
+_typemap.initialize(_backend)               # also creates (u)int8_t mapper
+
+try:
+    gbl.std.int8_t  = gbl.int8_t            # ensures same _integer_ type
+    gbl.std.uint8_t = gbl.uint8_t
+except (AttributeError, TypeError):
+    pass
+
+
+#- pythonization factories ---------------------------------------------------
+from . import _pythonization as py
+py._set_backend(_backend)
+
+def _standard_pythonizations(pyclass, name):
+  # pythonization of tuple; TODO: placed here for convenience, but a custom case
+  # for tuples on each platform can be made much more performant ...
+    if name.find('tuple<', 0, 6) == 0:
+        import cppjit
+        pyclass._tuple_len = cppjit.gbl.std.tuple_size(pyclass).value
+        def tuple_len(self):
+            return self.__class__._tuple_len
+        pyclass.__len__ = tuple_len
+        def tuple_getitem(self, idx, get=cppjit.gbl.std.get):
+            if idx < self.__class__._tuple_len:
+                res = get[idx](self)
+                try:
+                    res.__life_line = self
+                except Exception:
+                    pass
+                return res
+            raise IndexError(idx)
+        pyclass.__getitem__ = tuple_getitem
+
+  # pythonization of std::basic_string<char>; placed here because it's simpler to write the
+  # custom "npos" object (to allow easy result checking of find/rfind) in Python
+    elif pyclass.__cpp_name__ == "std::basic_string<char>":
+        class NPOS(int):
+            def __init__(self, npos):
+                self.__cpp_npos = npos
+            def __eq__(self, other):
+                return other == -1 or  other == self.__cpp_npos
+            def __ne__(self, other):
+                return other != -1 and other != self.__cpp_npos
+        if hasattr(pyclass.__class__, 'npos'):
+            del pyclass.__class__.npos          # drop b/c is const data
+        pyclass.npos = NPOS(pyclass.npos)
+
+    return True
+
+if not ispypy:
+    py.add_pythonization(_standard_pythonizations, "std")
+# TODO: PyPy still has the old-style pythonizations, which require the full
+# class name (not possible for std::tuple ...)
+
+# std::make_shared/unique create needless templates: rely on Python's introspection
+# instead. This also allows Python derived classes to be handled correctly.
+class py_make_smartptr(object):
+    __slots__ = ['cls', 'ptrcls']
+    def __init__(self, cls, ptrcls):
+        self.cls    = cls
+        self.ptrcls = ptrcls
+    def __call__(self, *args):
+        if len(args) == 1 and type(args[0]) == self.cls:
+            obj = args[0]
+        else:
+            obj = self.cls(*args)
+        return self.ptrcls[self.cls](obj)   # C++ takes ownership
+
+class make_smartptr(object):
+    __slots__ = ['ptrcls', 'maker']
+    def __init__(self, ptrcls, maker):
+        self.ptrcls = ptrcls
+        self.maker  = maker
+    def __call__(self, ptr):
+        return py_make_smartptr(type(ptr), self.ptrcls)(ptr)
+    def __getitem__(self, cls):
+        try:
+            if not cls.__module__ == int.__module__:
+                return py_make_smartptr(cls, self.ptrcls)
+        except AttributeError:
+            pass
+        if isinstance(cls, str) and not cls in ('int', 'float'):
+            return py_make_smartptr(getattr(gbl, cls), self.ptrcls)
+        return self.maker[cls]
+
+gbl.std.make_shared = make_smartptr(gbl.std.shared_ptr, gbl.std.make_shared)
+gbl.std.make_unique = make_smartptr(gbl.std.unique_ptr, gbl.std.make_unique)
+del make_smartptr
+
+
+#--- interface to Cling ------------------------------------------------------
+class _stderr_capture(object):
+    def __init__(self):
+       self._capture = not gbl.Cpp.IsDebugOutputEnabled()
+       self.err = ""
+
+    def __enter__(self):
+        if self._capture:
+           _begin_capture_stderr()
+        return self
+
+    def __exit__(self, tp, val, trace):
+        if self._capture:
+            self.err = _end_capture_stderr()
+
+def cppdef(src, verbose = True):
+    """Declare C++ source <src> to Cling."""
+    with _stderr_capture() as err:
+        errcode = gbl.Cpp.Declare(src, not verbose)
+    if not errcode == 0 or err.err:
+        if 'warning' in err.err.lower() and not 'error' in err.err.lower():
+            warnings.warn(err.err, SyntaxWarning)
+            return True
+        raise SyntaxError('Failed to parse the given C++ code%s' % err.err)
+    return True
+
+def cppexec(stmt):
+    """Execute C++ statement <stmt> in Cling's global scope."""
+    if stmt and stmt[-1] != ';':
+        stmt += ';'
+
+  # capture stderr, but note that Process could legitimately be writing to
+  # std::cerr, in which case the captured output needs to be printed as normal
+    with _stderr_capture() as err:
+        errcode = ctypes.c_int(0)
+        try:
+            errcode = gbl.Cpp.Process(stmt)
+        except Exception as e:
+            sys.stderr.write("%s\n\n" % str(e))
+            if not errcode.value: errcode.value = 1
+
+    if not errcode == 0:
+        raise SyntaxError('Failed to parse the given C++ code%s' % err.err)
+    elif err.err and err.err[1:] != '\n':
+        sys.stderr.write(err.err[1:])
+
+    return True
+
+def evaluate(input):
+    box = gbl.Cpp.Evaluate(input)
+    # Truthy sentinel: skips Box::convertTo's UB-on-K_Unspecified arm.
+    if box.getKind() == gbl.Cpp.Box.K_Unspecified:
+        return ~0
+    return box.convertTo['long']()
+
+def macro(cppm):
+    """Attempt to evalute a C/C++ pre-processor macro as a constant"""
+
+    try:
+        macro_val = getattr(getattr(gbl, '__cppjit_macros', None), cppm+'_', None)
+        if macro_val is None:
+            cppdef("namespace __cppjit_macros { auto %s_ = %s; }" % (cppm, cppm))
+        return getattr(getattr(gbl, '__cppjit_macros'), cppm+'_')
+    except Exception:
+        pass
+
+    raise ValueError('Failed to evaluate macro %s', cppm)
+
+
+def load_library(name):
+    """Explicitly load a shared library."""
+    with _stderr_capture() as err:
+        result = gbl.Cpp.LoadLibrary(name, True)
+    if result == False:
+        raise RuntimeError('Could not load library "%s": %s' % (name, err.err))
+
+    return True
+
+def include(header):
+    """Load (and JIT) header file <header> into Cling."""
+    with _stderr_capture() as err:
+        errcode = gbl.Cpp.Declare('#include "%s"' % header, False)
+    if not errcode == 0:
+        raise ImportError('Failed to load header file "%s"%s' % (header, err.err))
+    return True
+
+def c_include(header):
+    """Load (and JIT) header file <header> into Cling."""
+    with _stderr_capture() as err:
+        errcode = gbl.Cpp.Declare("""extern "C" {
+                                    #include "%s"
+                                    }""" % header, False)
+    if not errcode == 0:
+        raise ImportError('Failed to load header file "%s"%s' % (header, err.err))
+    return True
+
+def add_include_path(path):
+    """Add a path to the include paths available to Cling."""
+    if not os.path.isdir(path):
+        raise OSError('No such directory: %s' % path)
+    gbl.Cpp.AddIncludePath(path)
+
+def add_library_path(path):
+    """Add a path to the library search paths available to Cling."""
+    if not os.path.isdir(path):
+        raise OSError('No such directory: %s' % path)
+    gbl.Cpp.AddSearchPath(path, True, False)
+
+# add access to Python C-API headers
+apipath = sysconfig.get_path('include', 'posix_prefix' if os.name == 'posix' else os.name)
+if os.path.exists(apipath):
+    add_include_path(apipath)
+elif ispypy:
+  # possibly structured without 'pythonx.y' in path
+    apipath = os.path.dirname(apipath)
+    if os.path.exists(apipath) and os.path.exists(os.path.join(apipath, 'Python.h')):
+        add_include_path(apipath)
+
+# add access to extra headers for dispatcher (cpyrt only (?))
+if not ispypy:
+    try:
+        apipath_extra = os.environ['CPPJIT_API_PATH']
+        if os.path.basename(apipath_extra) == 'cpyrt':
+            apipath_extra = os.path.dirname(apipath_extra)
+    except KeyError:
+        apipath_extra = None
+
+    if apipath_extra is None:
+        try:
+            import pkg_resources as pr
+
+            d = pr.get_distribution('cpyrt')
+            for line in d.get_metadata_lines('RECORD'):
+                if 'API.h' in line:
+                    part = line[0:line.find(',')]
+
+            ape = os.path.join(d.location, part)
+            if os.path.exists(ape):
+                apipath_extra = os.path.dirname(os.path.dirname(ape))
+
+            del part, d, pr
+        except Exception:
+            pass
+
+    if apipath_extra is None:
+        # for the monorepo: headers are at cppjit_backend/include/
+        _cppjit_inc = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'cppjit_backend', 'include')
+        if os.path.exists(os.path.join(_cppjit_inc, 'cpyrt')):
+            apipath_extra = _cppjit_inc
+        del _cppjit_inc
+
+    if apipath_extra is None:
+        ldversion = sysconfig.get_config_var('LDVERSION')
+        if not ldversion: ldversion = sys.version[:3]
+
+        apipath_extra = os.path.join(os.path.dirname(apipath), 'site', 'python'+ldversion)
+        if not os.path.exists(os.path.join(apipath_extra, 'cpyrt')):
+            import glob, libcppjit
+            ape = os.path.dirname(libcppjit.__file__)
+          # a "normal" structure finds the include directory up to 3 levels up,
+          # ie. dropping lib/pythonx.y[md]/site-packages
+            for i in range(3):
+                if os.path.exists(os.path.join(ape, 'include')):
+                    break
+                ape = os.path.dirname(ape)
+
+            ape = os.path.join(ape, 'include')
+            if os.path.exists(os.path.join(ape, 'cpyrt')):
+                apipath_extra = ape
+            else:
+              # add back pythonx.y or site/pythonx.y if present
+                for p in glob.glob(os.path.join(ape, 'python'+sys.version[:3]+'*'))+\
+                         glob.glob(os.path.join(ape, '*', 'python'+sys.version[:3]+'*')):
+                    if os.path.exists(os.path.join(p, 'cpyrt')):
+                        apipath_extra = p
+                        break
+
+    if apipath_extra.lower() != 'none':
+        if not os.path.exists(os.path.join(apipath_extra, 'cpyrt')):
+            warnings.warn("cpyrt API not found (tried: %s); set CPPJIT_API_PATH envar to the 'cpyrt' API directory to fix" % apipath_extra)
+        else:
+            add_include_path(apipath_extra)
+
+    del apipath_extra
+
+if os.getenv('CONDA_PREFIX'):
+  # MacOS, Linux
+    include_path = os.path.join(os.getenv('CONDA_PREFIX'), 'include')
+    if os.path.exists(include_path): add_include_path(include_path)
+
+  # Windows
+    include_path = os.path.join(os.getenv('CONDA_PREFIX'), 'Library', 'include')
+    if os.path.exists(include_path): add_include_path(include_path)
+
+# assuming that we are in PREFIX/lib/python/site-packages/cppjit, add PREFIX/include to the search path
+include_path = os.path.abspath(os.path.join(os.path.dirname(__file__), *(4*[os.path.pardir]+['include'])))
+if os.path.exists(include_path): add_include_path(include_path)
+
+del include_path, apipath, ispypy
+
+def add_autoload_map(fname):
+    """Add the entries from a autoload (.rootmap) file to Cling."""
+    if not os.path.isfile(fname):
+        raise OSError("no such file: %s" % fname)
+    gbl.cling.runtime.gCling.LoadLibraryMap(fname)
+
+def set_debug(enable=True):
+    """Enable/disable debug output."""
+    gbl.Cpp.EnableDebugOutput(enable)
+
+def _get_name(tt):
+    if isinstance(tt, str):
+        return tt
+    try:
+        ttname = tt.__cpp_name__
+    except AttributeError:
+        ttname = tt.__name__
+    return ttname
+
+_sizes = {}
+def sizeof(tt):
+    """Returns the storage size (in chars) of C++ type <tt>."""
+    if not isinstance(tt, type) and not isinstance(tt, str):
+        tt = type(tt)
+    try:
+        return _sizes[tt]
+    except KeyError:
+        try:
+            sz = ctypes.sizeof(tt)
+        except TypeError:
+            # Route through evaluate() so the Box-returning Cpp::Evaluate
+            # is unboxed in one place (see the shim above). Cpp::SizeOf
+            # would be faster but its sibling Cpp::GetNamed does not
+            # traverse `Foo::Bar`-style qualified names, so handing it a
+            # nested `tt.__cpp_name__` resolves to a null scope and the
+            # subsequent SizeOf hangs/aborts. Stick with the legacy
+            # interpreter round-trip until we add a qualified-name
+            # resolver (or an overload of SizeOf that takes a name).
+            sz = evaluate("sizeof(%s)" % (_get_name(tt),))
+            #scope = gbl.Cpp.GetNamed(_get_name(tt))
+            #sz = gbl.Cpp.SizeOf(scope)
+        _sizes[tt] = sz
+        return sz
+
+_typeids = {}
+def typeid(tt):
+    """Returns the C++ runtime type information for type <tt>."""
+    if not isinstance(tt, type):
+        tt = type(tt)
+    try:
+        return _typeids[tt]
+    except KeyError:
+        tidname = 'typeid_'+str(len(_typeids))
+        cppexec(
+            "namespace _cppjit_internal { auto* %s = &typeid(%s); }" %\
+            (tidname, _get_name(tt),))
+        tid = getattr(gbl._cppjit_internal, tidname)
+        _typeids[tt] = tid
+        return tid
+
+def multi(*bases):      # after six, see also _typemap.py
+    """Resolve metaclasses for multiple inheritance."""
+  # contruct a "no conflict" meta class; the '_meta' is needed by convention
+    nc_meta = type.__new__(type, 'cppjit_nc_meta', tuple(type(b) for b in bases if type(b) is not type), {})
+    class faux_meta(type):
+        def __new__(mcs, name, this_bases, d):
+            return nc_meta(name, bases, d)
+    return type.__new__(faux_meta, 'faux_meta', (), {})
+
+
+#- workaround (TODO: may not be needed with Clang9) --------------------------
+if 'win32' in sys.platform:
+    cppdef("""template<>
+    std::basic_ostream<char, std::char_traits<char>>& __cdecl std::endl<char, std::char_traits<char>>(
+        std::basic_ostream<char, std::char_traits<char>>&);""")
diff --git a/python/cppjit/cppyy/__pyinstaller/__init__.py b/python/cppjit/__pyinstaller/__init__.py
similarity index 100%
rename from python/cppjit/cppyy/__pyinstaller/__init__.py
rename to python/cppjit/__pyinstaller/__init__.py
diff --git a/python/cppjit/__pyinstaller/hook-cppjit.py b/python/cppjit/__pyinstaller/hook-cppjit.py
new file mode 100644
index 0000000..d5caadf
--- /dev/null
+++ b/python/cppjit/__pyinstaller/hook-cppjit.py
@@ -0,0 +1,35 @@
+# PyInstaller hooks to declare the "data files" (libraries, headers, etc.) of
+# cppjit-backend. Placed here rather then in cppjit-backend to guarantee that any
+# packaging of top-level "cppjit" picks up the backend as well.
+#
+# See also setup.cfg.
+
+__all__ = ['data']
+
+
+def _backend_files():
+    import cppjit_backend, glob, os
+
+    all_files = glob.glob(os.path.join(
+        os.path.dirname(cppjit_backend.__file__), '*'))
+
+    def datafile(path):
+        return path, os.path.join('cppjit_backend', os.path.basename(path))
+
+    return [datafile(filename) for filename in all_files if os.path.isdir(filename)]
+
+def _api_files():
+    import cppjit, os
+
+    # FIXME: We should add an interface in InterOp.
+    paths = str(cppjit.gbl.runtime.gCling.GetIncludePath()).split('-I')
+    for p in paths:
+        if not p: continue
+
+        apipath = os.path.join(p.strip()[1:-1], 'cpyrt')
+        if os.path.exists(apipath):
+            return [(apipath, os.path.join('include', 'cpyrt'))]
+
+    return []
+
+datas = _backend_files()+_api_files()
diff --git a/python/cppjit/cppyy/_cpython_cppyy.py b/python/cppjit/_cpython_cppjit.py
similarity index 93%
rename from python/cppjit/cppyy/_cpython_cppyy.py
rename to python/cppjit/_cpython_cppjit.py
index 543cda5..49cb5d8 100644
--- a/python/cppjit/cppyy/_cpython_cppyy.py
+++ b/python/cppjit/_cpython_cppjit.py
@@ -5,7 +5,7 @@
 import sys
 
 from . import _stdcpp_fix
-from ..cppyy_backend import loader
+from cppjit_backend import loader
 
 __all__ = [
     'gbl',
@@ -20,12 +20,12 @@
     ]
 
 # first load the dependency libraries of the backend, then pull in the
-# libcppyy extension module
+# libcppjit extension module
 # c = loader.load_cpp_backend()
-from .. import libcppyy as _backend
+import libcppjit as _backend
 # _backend._cpp_backend = c
 
-# explicitly expose APIs from libcppyy
+# explicitly expose APIs from libcppjit
 _w = ctypes.CDLL(_backend.__file__, ctypes.RTLD_GLOBAL)
 
 
@@ -34,7 +34,7 @@
   # TODO: this reliese on CPPOverload cooking up a func_code object, which atm
   # is simply not implemented for p3 :/
 
-  # convince inspect that cppyy method proxies are possible drop-ins for python
+  # convince inspect that cppjit method proxies are possible drop-ins for python
   # methods and classes for pydoc
     import inspect
 
@@ -55,7 +55,7 @@ def ismethod(object):
 
 
 ### template support ---------------------------------------------------------
-class Template(object):  # expected/used by ProxyWrappers.cxx in CPyCppyy
+class Template(object):  # expected/used by ProxyWrappers.cxx in cpyrt
     stl_sequence_types   = ['std::vector', 'std::list', 'std::set', 'std::deque']
     stl_unrolled_types   = ['std::pair']
     stl_fixed_size_types = ['std::array']
@@ -68,7 +68,7 @@ def __init__(self, name, scope):
         self.__scope__    = scope
 
     def __repr__(self):
-        return "<cppyy.Template '%s' object at %s>" % (self.__name__, hex(id(self)))
+        return "<cppjit.Template '%s' object at %s>" % (self.__name__, hex(id(self)))
 
     def __getitem__(self, *args):
       # multi-argument to [] becomes a single tuple argument
@@ -149,7 +149,7 @@ def __call__(self, *args):
 
 #- :: and std:: namespaces ---------------------------------------------------
 gbl = _backend.CreateScopeProxy('')
-gbl.__class__.__repr__ = lambda cls : '<namespace cppyy.gbl at 0x%x>' % id(cls)
+gbl.__class__.__repr__ = lambda cls : '<namespace cppjit.gbl at 0x%x>' % id(cls)
 gbl.std =  _backend.CreateScopeProxy('std')
 # for move, we want our "pythonized" one, not the C++ template
 gbl.std.move  = _backend.move
@@ -168,7 +168,7 @@ def add_default_paths():
         lib_path = os.path.join(os.getenv('CONDA_PREFIX'), 'Library', 'lib')
         if os.path.exists(lib_path): Cpp.AddSearchPath(lib_path, True, False)
 
-  # assuming that we are in PREFIX/lib/python/site-packages/cppyy, add PREFIX/lib to the search path
+  # assuming that we are in PREFIX/lib/python/site-packages/cppjit, add PREFIX/lib to the search path
     lib_path = os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir, os.path.pardir))
     if os.path.exists(lib_path): Cpp.AddSearchPath(lib_path, True, False)
 
diff --git a/python/cppjit/cppyy/_pypy_cppyy.py b/python/cppjit/_pypy_cppjit.py
similarity index 83%
rename from python/cppjit/cppyy/_pypy_cppyy.py
rename to python/cppjit/_pypy_cppjit.py
index e6e237e..bab3ab6 100644
--- a/python/cppjit/cppyy/_pypy_cppyy.py
+++ b/python/cppjit/_pypy_cppjit.py
@@ -4,7 +4,7 @@
 from . import _stdcpp_fix
 
 import os, sys
-from ..cppyy_backend import loader
+from cppjit_backend import loader
 
 __all__ = [
     'gbl',
@@ -14,23 +14,23 @@
     ]
 
 # first load the dependency libraries of the backend, then
-# pull in the built-in low-level cppyy
+# pull in the built-in low-level cppjit
 try:
     c = loader.load_cpp_backend()
 except RuntimeError:
     import sysconfig
-    os.environ['CPPYY_BACKEND_LIBRARY'] = "libcppyy_backend"+sysconfig.get_config_var("SO")
+    os.environ['CPPJIT_BACKEND_LIBRARY'] = "libcppjit_backend"+sysconfig.get_config_var("SO")
     c = loader.load_cpp_backend()
-os.environ['CPPYY_BACKEND_LIBRARY'] = c._name
+os.environ['CPPJIT_BACKEND_LIBRARY'] = c._name
 
 # some older versions can be fixed up through a compatibility
 # module on the python side; load it, if available
 try:
-    import cppyy_compat
+    import cppjit_compat
 except ImportError:
     pass
 
-import _cppyy as _backend     # built-in module
+import _cppjit as _backend     # built-in module
 try:
     _backend._post_import_startup()
 except AttributeError:
diff --git a/python/cppjit/cppyy/_pythonization.py b/python/cppjit/_pythonization.py
similarity index 100%
rename from python/cppjit/cppyy/_pythonization.py
rename to python/cppjit/_pythonization.py
diff --git a/python/cppjit/cppyy/_stdcpp_fix.py b/python/cppjit/_stdcpp_fix.py
similarity index 100%
rename from python/cppjit/cppyy/_stdcpp_fix.py
rename to python/cppjit/_stdcpp_fix.py
diff --git a/python/cppjit/cppyy/_typemap.py b/python/cppjit/_typemap.py
similarity index 95%
rename from python/cppjit/cppyy/_typemap.py
rename to python/cppjit/_typemap.py
index 549dab7..133c5a5 100644
--- a/python/cppjit/cppyy/_typemap.py
+++ b/python/cppjit/_typemap.py
@@ -10,10 +10,10 @@ def _create_mapper(cls, extra_dct=None):
     def mapper(name, scope):
         if scope:
             cppname = scope+'::'+name
-            modname = 'cppyy.gbl.'+scope
+            modname = 'cppjit.gbl.'+scope
         else:
             cppname = name
-            modname = 'cppyy.gbl'
+            modname = 'cppjit.gbl'
         dct = {'__cpp_name__' : cppname, '__module__' : modname}
         if extra_dct: dct.update(extra_dct)
         return type(name, (cls,), dct)
@@ -110,8 +110,7 @@ def initialize(backend):
 
     # void*
     def voidp_init(self, arg=0):
-        from cppjit import cppyy
-        import ctypes
-        if arg == cppyy.nullptr: arg = 0
+        import cppjit, ctypes
+        if arg == cppjit.nullptr: arg = 0
         ctypes.c_void_p.__init__(self, arg)
     tm['void *'] = _create_mapper(ctypes.c_void_p, {'__init__' : voidp_init})
diff --git a/python/cppjit/cppyy/_version.py b/python/cppjit/_version.py
similarity index 100%
rename from python/cppjit/cppyy/_version.py
rename to python/cppjit/_version.py
diff --git a/python/cppjit/cppyy/__init__.py b/python/cppjit/cppyy/__init__.py
deleted file mode 100644
index 9ca8349..0000000
--- a/python/cppjit/cppyy/__init__.py
+++ /dev/null
@@ -1,465 +0,0 @@
-"""Dynamic C++ bindings generator.
-
-This module provides dynamic bindings to C++ through Cling, the LLVM-based C++
-interpreter, allowing interactive mixing of Python and C++. Example:
-
-    >>> import cppyy
-    >>> cppyy.cppdef(\"\"\"
-    ... class MyClass {
-    ... public:
-    ...     MyClass(int i) : m_data(i) {}
-    ...     int m_data;
-    ... };\"\"\")
-    True
-    >>> from cppyy.gbl import MyClass
-    >>> m = MyClass(42)
-    >>> cppyy.cppdef(\"\"\"
-    ... void say_hello(MyClass* m) {
-    ...     std::cout << "Hello, the number is: " << m->m_data << std::endl;
-    ... }\"\"\")
-    True
-    >>> MyClass.say_hello = cppyy.gbl.say_hello
-    >>> m.say_hello()
-    Hello, the number is: 42
-    >>> m.m_data = 13
-    >>> m.say_hello()
-    Hello, the number is: 13
-    >>>
-
-For full documentation, see:
-   https://cppyy.readthedocs.io/
-
-"""
-
-__author__ = 'Wim Lavrijsen <WLavrijsen@lbl.gov>'
-
-__all__ = [
-    'cppdef',                 # declare C++ source to Cling
-    'cppexec',                # execute a C++ statement
-    'macro',                  # attempt to evaluate a cpp macro
-    'include',                # load and jit a header file
-    'c_include',              # load and jit a C header file
-    'load_library',           # load a shared library
-    'nullptr',                # unique pointer representing NULL
-    'sizeof',                 # size of a C++ type
-    'typeid',                 # typeid of a C++ type
-    'multi',                  # helper for multiple inheritance
-    'add_include_path',       # add a path to search for headers
-    'add_library_path',       # add a path to search for libraries
-    'add_autoload_map',       # explicitly include an autoload map
-    'set_debug',              # enable/disable debug output
-    ]
-
-import ctypes, os, sys, sysconfig, warnings
-
-if not 'CLING_STANDARD_PCH' in os.environ:
-    def _set_pch():
-        try:
-            from .. import cppyy_backend as cpb
-            local_pch = os.path.join(os.path.dirname(__file__), 'allDict.cxx.pch.'+str(cpb.__version__))
-            if os.path.exists(local_pch):
-                os.putenv('CLING_STANDARD_PCH', local_pch)
-                os.environ['CLING_STANDARD_PCH'] = local_pch
-        except (ImportError, AttributeError):
-            pass
-    _set_pch(); del _set_pch
-
-try:
-    import __pypy__
-    del __pypy__
-    ispypy = True
-except ImportError:
-    ispypy = False
-
-from . import _typemap
-from ._version import __version__
-
-# import separately instead of in the above try/except block for easier to
-# understand tracebacks
-if ispypy:
-    from ._pypy_cppyy import *
-else:
-    from ._cpython_cppyy import *
-
-
-#- allow importing from gbl --------------------------------------------------
-sys.modules['cppyy.gbl'] = gbl
-sys.modules['cppyy.gbl.std'] = gbl.std
-
-
-#- force creation of std.exception -------------------------------------------------------
-_e = gbl.std.exception
-
-
-#- enable auto-loading -------------------------------------------------------
-try:    gbl.cling.runtime.gCling.EnableAutoLoading()
-except: pass
-
-
-#- external typemap ----------------------------------------------------------
-_typemap.initialize(_backend)               # also creates (u)int8_t mapper
-
-try:
-    gbl.std.int8_t  = gbl.int8_t            # ensures same _integer_ type
-    gbl.std.uint8_t = gbl.uint8_t
-except (AttributeError, TypeError):
-    pass
-
-
-#- pythonization factories ---------------------------------------------------
-from . import _pythonization as py
-py._set_backend(_backend)
-
-def _standard_pythonizations(pyclass, name):
-  # pythonization of tuple; TODO: placed here for convenience, but a custom case
-  # for tuples on each platform can be made much more performant ...
-    if name.find('tuple<', 0, 6) == 0:
-        from cppjit import cppyy
-        pyclass._tuple_len = cppyy.gbl.std.tuple_size(pyclass).value
-        def tuple_len(self):
-            return self.__class__._tuple_len
-        pyclass.__len__ = tuple_len
-        def tuple_getitem(self, idx, get=cppyy.gbl.std.get):
-            if idx < self.__class__._tuple_len:
-                res = get[idx](self)
-                try:
-                    res.__life_line = self
-                except Exception:
-                    pass
-                return res
-            raise IndexError(idx)
-        pyclass.__getitem__ = tuple_getitem
-
-  # pythonization of std::basic_string<char>; placed here because it's simpler to write the
-  # custom "npos" object (to allow easy result checking of find/rfind) in Python
-    elif pyclass.__cpp_name__ == "std::basic_string<char>":
-        class NPOS(int):
-            def __init__(self, npos):
-                self.__cpp_npos = npos
-            def __eq__(self, other):
-                return other == -1 or  other == self.__cpp_npos
-            def __ne__(self, other):
-                return other != -1 and other != self.__cpp_npos
-        if hasattr(pyclass.__class__, 'npos'):
-            del pyclass.__class__.npos          # drop b/c is const data
-        pyclass.npos = NPOS(pyclass.npos)
-
-    return True
-
-if not ispypy:
-    py.add_pythonization(_standard_pythonizations, "std")
-# TODO: PyPy still has the old-style pythonizations, which require the full
-# class name (not possible for std::tuple ...)
-
-# std::make_shared/unique create needless templates: rely on Python's introspection
-# instead. This also allows Python derived classes to be handled correctly.
-class py_make_smartptr(object):
-    __slots__ = ['cls', 'ptrcls']
-    def __init__(self, cls, ptrcls):
-        self.cls    = cls
-        self.ptrcls = ptrcls
-    def __call__(self, *args):
-        if len(args) == 1 and type(args[0]) == self.cls:
-            obj = args[0]
-        else:
-            obj = self.cls(*args)
-        return self.ptrcls[self.cls](obj)   # C++ takes ownership
-
-class make_smartptr(object):
-    __slots__ = ['ptrcls', 'maker']
-    def __init__(self, ptrcls, maker):
-        self.ptrcls = ptrcls
-        self.maker  = maker
-    def __call__(self, ptr):
-        return py_make_smartptr(type(ptr), self.ptrcls)(ptr)
-    def __getitem__(self, cls):
-        try:
-            if not cls.__module__ == int.__module__:
-                return py_make_smartptr(cls, self.ptrcls)
-        except AttributeError:
-            pass
-        if isinstance(cls, str) and not cls in ('int', 'float'):
-            return py_make_smartptr(getattr(gbl, cls), self.ptrcls)
-        return self.maker[cls]
-
-gbl.std.make_shared = make_smartptr(gbl.std.shared_ptr, gbl.std.make_shared)
-gbl.std.make_unique = make_smartptr(gbl.std.unique_ptr, gbl.std.make_unique)
-del make_smartptr
-
-
-#--- interface to Cling ------------------------------------------------------
-class _stderr_capture(object):
-    def __init__(self):
-       self._capture = not gbl.Cpp.IsDebugOutputEnabled()
-       self.err = ""
-
-    def __enter__(self):
-        if self._capture:
-           _begin_capture_stderr()
-        return self
-
-    def __exit__(self, tp, val, trace):
-        if self._capture:
-            self.err = _end_capture_stderr()
-
-def cppdef(src, verbose = True):
-    """Declare C++ source <src> to Cling."""
-    with _stderr_capture() as err:
-        errcode = gbl.Cpp.Declare(src, not verbose)
-    if not errcode == 0 or err.err:
-        if 'warning' in err.err.lower() and not 'error' in err.err.lower():
-            warnings.warn(err.err, SyntaxWarning)
-            return True
-        raise SyntaxError('Failed to parse the given C++ code%s' % err.err)
-    return True
-
-def cppexec(stmt):
-    """Execute C++ statement <stmt> in Cling's global scope."""
-    if stmt and stmt[-1] != ';':
-        stmt += ';'
-
-  # capture stderr, but note that Process could legitimately be writing to
-  # std::cerr, in which case the captured output needs to be printed as normal
-    with _stderr_capture() as err:
-        errcode = ctypes.c_int(0)
-        try:
-            errcode = gbl.Cpp.Process(stmt)
-        except Exception as e:
-            sys.stderr.write("%s\n\n" % str(e))
-            if not errcode.value: errcode.value = 1
-
-    if not errcode == 0:
-        raise SyntaxError('Failed to parse the given C++ code%s' % err.err)
-    elif err.err and err.err[1:] != '\n':
-        sys.stderr.write(err.err[1:])
-
-    return True
-
-def evaluate(input):
-    box = gbl.Cpp.Evaluate(input)
-    # Truthy sentinel: skips Box::convertTo's UB-on-K_Unspecified arm.
-    if box.getKind() == gbl.Cpp.Box.K_Unspecified:
-        return ~0
-    return box.convertTo['long']()
-
-def macro(cppm):
-    """Attempt to evalute a C/C++ pre-processor macro as a constant"""
-
-    try:
-        macro_val = getattr(getattr(gbl, '__cppyy_macros', None), cppm+'_', None)
-        if macro_val is None:
-            cppdef("namespace __cppyy_macros { auto %s_ = %s; }" % (cppm, cppm))
-        return getattr(getattr(gbl, '__cppyy_macros'), cppm+'_')
-    except Exception:
-        pass
-
-    raise ValueError('Failed to evaluate macro %s', cppm)
-
-
-def load_library(name):
-    """Explicitly load a shared library."""
-    with _stderr_capture() as err:
-        result = gbl.Cpp.LoadLibrary(name, True)
-    if result == False:
-        raise RuntimeError('Could not load library "%s": %s' % (name, err.err))
-
-    return True
-
-def include(header):
-    """Load (and JIT) header file <header> into Cling."""
-    with _stderr_capture() as err:
-        errcode = gbl.Cpp.Declare('#include "%s"' % header, False)
-    if not errcode == 0:
-        raise ImportError('Failed to load header file "%s"%s' % (header, err.err))
-    return True
-
-def c_include(header):
-    """Load (and JIT) header file <header> into Cling."""
-    with _stderr_capture() as err:
-        errcode = gbl.Cpp.Declare("""extern "C" {
-                                    #include "%s"
-                                    }""" % header, False)
-    if not errcode == 0:
-        raise ImportError('Failed to load header file "%s"%s' % (header, err.err))
-    return True
-
-def add_include_path(path):
-    """Add a path to the include paths available to Cling."""
-    if not os.path.isdir(path):
-        raise OSError('No such directory: %s' % path)
-    gbl.Cpp.AddIncludePath(path)
-
-def add_library_path(path):
-    """Add a path to the library search paths available to Cling."""
-    if not os.path.isdir(path):
-        raise OSError('No such directory: %s' % path)
-    gbl.Cpp.AddSearchPath(path, True, False)
-
-# add access to Python C-API headers
-apipath = sysconfig.get_path('include', 'posix_prefix' if os.name == 'posix' else os.name)
-if os.path.exists(apipath):
-    add_include_path(apipath)
-elif ispypy:
-  # possibly structured without 'pythonx.y' in path
-    apipath = os.path.dirname(apipath)
-    if os.path.exists(apipath) and os.path.exists(os.path.join(apipath, 'Python.h')):
-        add_include_path(apipath)
-
-# add access to extra headers for dispatcher (CPyCppyy only (?))
-if not ispypy:
-    try:
-        apipath_extra = os.environ['CPPYY_API_PATH']
-        if os.path.basename(apipath_extra) == 'CPyCppyy':
-            apipath_extra = os.path.dirname(apipath_extra)
-    except KeyError:
-        apipath_extra = None
-
-    if apipath_extra is None:
-        try:
-            import pkg_resources as pr
-
-            d = pr.get_distribution('CPyCppyy')
-            for line in d.get_metadata_lines('RECORD'):
-                if 'API.h' in line:
-                    part = line[0:line.find(',')]
-
-            ape = os.path.join(d.location, part)
-            if os.path.exists(ape):
-                apipath_extra = os.path.dirname(os.path.dirname(ape))
-
-            del part, d, pr
-        except Exception:
-            pass
-
-    if apipath_extra is None:
-        # for the monorepo: headers are at cppjit/cppyy_backend/include/
-        _cppjit_inc = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'cppyy_backend', 'include')
-        if os.path.exists(os.path.join(_cppjit_inc, 'CPyCppyy')):
-            apipath_extra = _cppjit_inc
-        del _cppjit_inc
-
-    if apipath_extra is None:
-        ldversion = sysconfig.get_config_var('LDVERSION')
-        if not ldversion: ldversion = sys.version[:3]
-
-        apipath_extra = os.path.join(os.path.dirname(apipath), 'site', 'python'+ldversion)
-        if not os.path.exists(os.path.join(apipath_extra, 'CPyCppyy')):
-            import glob
-            from .. import libcppyy
-            ape = os.path.dirname(libcppyy.__file__)
-          # a "normal" structure finds the include directory up to 3 levels up,
-          # ie. dropping lib/pythonx.y[md]/site-packages
-            for i in range(3):
-                if os.path.exists(os.path.join(ape, 'include')):
-                    break
-                ape = os.path.dirname(ape)
-
-            ape = os.path.join(ape, 'include')
-            if os.path.exists(os.path.join(ape, 'CPyCppyy')):
-                apipath_extra = ape
-            else:
-              # add back pythonx.y or site/pythonx.y if present
-                for p in glob.glob(os.path.join(ape, 'python'+sys.version[:3]+'*'))+\
-                         glob.glob(os.path.join(ape, '*', 'python'+sys.version[:3]+'*')):
-                    if os.path.exists(os.path.join(p, 'CPyCppyy')):
-                        apipath_extra = p
-                        break
-
-    if apipath_extra.lower() != 'none':
-        if not os.path.exists(os.path.join(apipath_extra, 'CPyCppyy')):
-            warnings.warn("CPyCppyy API not found (tried: %s); set CPPYY_API_PATH envar to the 'CPyCppyy' API directory to fix" % apipath_extra)
-        else:
-            add_include_path(apipath_extra)
-
-    del apipath_extra
-
-if os.getenv('CONDA_PREFIX'):
-  # MacOS, Linux
-    include_path = os.path.join(os.getenv('CONDA_PREFIX'), 'include')
-    if os.path.exists(include_path): add_include_path(include_path)
-
-  # Windows
-    include_path = os.path.join(os.getenv('CONDA_PREFIX'), 'Library', 'include')
-    if os.path.exists(include_path): add_include_path(include_path)
-
-# assuming that we are in PREFIX/lib/python/site-packages/cppyy, add PREFIX/include to the search path
-include_path = os.path.abspath(os.path.join(os.path.dirname(__file__), *(4*[os.path.pardir]+['include'])))
-if os.path.exists(include_path): add_include_path(include_path)
-
-del include_path, apipath, ispypy
-
-def add_autoload_map(fname):
-    """Add the entries from a autoload (.rootmap) file to Cling."""
-    if not os.path.isfile(fname):
-        raise OSError("no such file: %s" % fname)
-    gbl.cling.runtime.gCling.LoadLibraryMap(fname)
-
-def set_debug(enable=True):
-    """Enable/disable debug output."""
-    gbl.Cpp.EnableDebugOutput(enable)
-
-def _get_name(tt):
-    if isinstance(tt, str):
-        return tt
-    try:
-        ttname = tt.__cpp_name__
-    except AttributeError:
-        ttname = tt.__name__
-    return ttname
-
-_sizes = {}
-def sizeof(tt):
-    """Returns the storage size (in chars) of C++ type <tt>."""
-    if not isinstance(tt, type) and not isinstance(tt, str):
-        tt = type(tt)
-    try:
-        return _sizes[tt]
-    except KeyError:
-        try:
-            sz = ctypes.sizeof(tt)
-        except TypeError:
-            # Route through evaluate() so the Box-returning Cpp::Evaluate
-            # is unboxed in one place (see the shim above). Cpp::SizeOf
-            # would be faster but its sibling Cpp::GetNamed does not
-            # traverse `Foo::Bar`-style qualified names, so handing it a
-            # nested `tt.__cpp_name__` resolves to a null scope and the
-            # subsequent SizeOf hangs/aborts. Stick with the legacy
-            # interpreter round-trip until we add a qualified-name
-            # resolver (or an overload of SizeOf that takes a name).
-            sz = evaluate("sizeof(%s)" % (_get_name(tt),))
-            #scope = gbl.Cpp.GetNamed(_get_name(tt))
-            #sz = gbl.Cpp.SizeOf(scope)
-        _sizes[tt] = sz
-        return sz
-
-_typeids = {}
-def typeid(tt):
-    """Returns the C++ runtime type information for type <tt>."""
-    if not isinstance(tt, type):
-        tt = type(tt)
-    try:
-        return _typeids[tt]
-    except KeyError:
-        tidname = 'typeid_'+str(len(_typeids))
-        cppexec(
-            "namespace _cppyy_internal { auto* %s = &typeid(%s); }" %\
-            (tidname, _get_name(tt),))
-        tid = getattr(gbl._cppyy_internal, tidname)
-        _typeids[tt] = tid
-        return tid
-
-def multi(*bases):      # after six, see also _typemap.py
-    """Resolve metaclasses for multiple inheritance."""
-  # contruct a "no conflict" meta class; the '_meta' is needed by convention
-    nc_meta = type.__new__(type, 'cppyy_nc_meta', tuple(type(b) for b in bases if type(b) is not type), {})
-    class faux_meta(type):
-        def __new__(mcs, name, this_bases, d):
-            return nc_meta(name, bases, d)
-    return type.__new__(faux_meta, 'faux_meta', (), {})
-
-
-#- workaround (TODO: may not be needed with Clang9) --------------------------
-if 'win32' in sys.platform:
-    cppdef("""template<>
-    std::basic_ostream<char, std::char_traits<char>>& __cdecl std::endl<char, std::char_traits<char>>(
-        std::basic_ostream<char, std::char_traits<char>>&);""")
diff --git a/python/cppjit/cppyy/__pyinstaller/hook-cppyy.py b/python/cppjit/cppyy/__pyinstaller/hook-cppyy.py
deleted file mode 100644
index e7560ef..0000000
--- a/python/cppjit/cppyy/__pyinstaller/hook-cppyy.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# PyInstaller hooks to declare the "data files" (libraries, headers, etc.) of
-# cppyy-backend. Placed here rather then in cppyy-backend to guarantee that any
-# packaging of top-level "cppyy" picks up the backend as well.
-#
-# See also setup.cfg.
-
-__all__ = ['data']
-
-
-def _backend_files():
-    from cppjit import cppyy_backend
-    import glob, os
-
-    all_files = glob.glob(os.path.join(
-        os.path.dirname(cppyy_backend.__file__), '*'))
-
-    def datafile(path):
-        return path, os.path.join('cppyy_backend', os.path.basename(path))
-
-    return [datafile(filename) for filename in all_files if os.path.isdir(filename)]
-
-def _api_files():
-    from cppjit import cppyy
-    import os
-
-    # FIXME: We should add an interface in InterOp.
-    paths = str(cppyy.gbl.runtime.gCling.GetIncludePath()).split('-I')
-    for p in paths:
-        if not p: continue
-
-        apipath = os.path.join(p.strip()[1:-1], 'CPyCppyy')
-        if os.path.exists(apipath):
-            return [(apipath, os.path.join('include', 'CPyCppyy'))]
-
-    return []
-
-datas = _backend_files()+_api_files()
diff --git a/python/cppjit/cppyy/reflex.py b/python/cppjit/cppyy/reflex.py
deleted file mode 100644
index c8063b8..0000000
--- a/python/cppjit/cppyy/reflex.py
+++ /dev/null
@@ -1,28 +0,0 @@
-""" cppyy reflection
-"""
-
-from cppjit import cppyy
-
-try:
-    import __pypy__
-    __all__ = [
-
-    ]
-
-except ImportError:
-    __all__ = [
-       'RETURN_TYPE',
-    ]
-
-    cppyy.include("CPyCppyy/Reflex.h")
-
-    IS_NAMESPACE   = cppyy.gbl.Cppyy.Reflex.IS_NAMESPACE
-    IS_AGGREGATE   = cppyy.gbl.Cppyy.Reflex.IS_AGGREGATE
-
-    OFFSET         = cppyy.gbl.Cppyy.Reflex.OFFSET
-    RETURN_TYPE    = cppyy.gbl.Cppyy.Reflex.RETURN_TYPE
-    TYPE           = cppyy.gbl.Cppyy.Reflex.TYPE
-
-    OPTIMAL        = cppyy.gbl.Cppyy.Reflex.OPTIMAL
-    AS_TYPE        = cppyy.gbl.Cppyy.Reflex.AS_TYPE
-    AS_STRING      = cppyy.gbl.Cppyy.Reflex.AS_STRING
diff --git a/python/cppjit/cppyy/interactive.py b/python/cppjit/interactive.py
similarity index 52%
rename from python/cppjit/cppyy/interactive.py
rename to python/cppjit/interactive.py
index ef9893b..7ee8f64 100644
--- a/python/cppjit/cppyy/interactive.py
+++ b/python/cppjit/interactive.py
@@ -13,25 +13,25 @@ def __init__(self, hook_okay):
         self._hook_okay = hook_okay
 
     def __getattr__(self, attr):
-        from cppjit import cppyy
+        import cppjit
 
         if attr == '__all__':
-          # copy all exported items from cppyy itself
-            for v in cppyy.__all__:
-                self.__dict__[v] = getattr(cppyy, v)
+          # copy all exported items from cppjit itself
+            for v in cppjit.__all__:
+                self.__dict__[v] = getattr(cppjit, v)
 
-          # add the lookup hook into cppyy.gbl if legal, or put it under 'g'
+          # add the lookup hook into cppjit.gbl if legal, or put it under 'g'
           # if not (PyPy and IPython for now)
             if self._hook_okay:
                 caller = sys.modules[sys._getframe(1).f_globals['__name__']]
-                cppyy._backend._set_cpp_lazy_lookup(caller.__dict__)
-                return cppyy.__all__
+                cppjit._backend._set_cpp_lazy_lookup(caller.__dict__)
+                return cppjit.__all__
             else:
-                self.__dict__['g']   = cppyy.gbl
-                self.__dict__['std'] = cppyy.gbl.std
-                return ['g', 'std']+cppyy.__all__
-        return getattr(cppyy, attr)
+                self.__dict__['g']   = cppjit.gbl
+                self.__dict__['std'] = cppjit.gbl.std
+                return ['g', 'std']+cppjit.__all__
+        return getattr(cppjit, attr)
 
-sys.modules['cppyy.interactive'] = InteractiveLazy(\
+sys.modules['cppjit.interactive'] = InteractiveLazy(\
     not ispypy and not (hasattr(__builtins__, '__IPYTHON__') or 'IPython' in sys.modules))
 del InteractiveLazy, ispypy
diff --git a/python/cppjit/cppyy/ll.py b/python/cppjit/ll.py
similarity index 62%
rename from python/cppjit/cppyy/ll.py
rename to python/cppjit/ll.py
index 58612ee..bec3290 100644
--- a/python/cppjit/cppyy/ll.py
+++ b/python/cppjit/ll.py
@@ -1,7 +1,7 @@
 """ Low-level utilities, to be used for "emergencies only".
 """
 
-from cppjit import cppyy
+import cppjit
 import ctypes
 import sys
 import warnings
@@ -46,38 +46,38 @@ def argc():
 # import low-level python converters
 for _name in ['addressof', 'as_cobject', 'as_capsule', 'as_ctypes', 'as_memoryview']:
     try:
-        exec('%s = cppyy._backend.%s' % (_name, _name))
+        exec('%s = cppjit._backend.%s' % (_name, _name))
         __all__.append(_name)
     except AttributeError:
         pass
 del _name
 
 # create low-level helpers once
-if not hasattr(cppyy.gbl, "__cppyy_internal") or \
-   not hasattr(cppyy.gbl.__cppyy_internal, "cppyy_cast"):
-    cppyy.cppdef("""namespace __cppyy_internal {
+if not hasattr(cppjit.gbl, "__cppjit_internal") or \
+   not hasattr(cppjit.gbl.__cppjit_internal, "cppjit_cast"):
+    cppjit.cppdef("""namespace __cppjit_internal {
     // type casting
       template<typename T, typename U>
-      T cppyy_cast(U val) { return (T)val; }
+      T cppjit_cast(U val) { return (T)val; }
 
       template<typename T, typename U>
-      T cppyy_static_cast(U val) { return static_cast<T>(val); }
+      T cppjit_static_cast(U val) { return static_cast<T>(val); }
 
       template<typename T, typename U>
-      T cppyy_reinterpret_cast(U val) { return reinterpret_cast<T>(val); }
+      T cppjit_reinterpret_cast(U val) { return reinterpret_cast<T>(val); }
 
       template<typename T, typename S>
-      T* cppyy_dynamic_cast(S* obj) { return dynamic_cast<T*>(obj); }
+      T* cppjit_dynamic_cast(S* obj) { return dynamic_cast<T*>(obj); }
 
     // memory allocation/free-ing
       template<typename T>
-      T* cppyy_malloc(size_t count=1) { return (T*)malloc(sizeof(T*)*count); }
+      T* cppjit_malloc(size_t count=1) { return (T*)malloc(sizeof(T*)*count); }
 
       template<typename T>
-      T* cppyy_array_new(size_t count) { return new T[count]; }
+      T* cppjit_array_new(size_t count) { return new T[count]; }
 
       template<typename T>
-      void cppyy_array_delete(T* ptr) { delete[] ptr; }
+      void cppjit_array_delete(T* ptr) { delete[] ptr; }
     }""")
 
 # helper for sizing arrays
@@ -106,33 +106,33 @@ def __call__(self, size, managed=False):
 
 
 # import casting helpers
-cast             = cppyy.gbl.__cppyy_internal.cppyy_cast
-static_cast      = cppyy.gbl.__cppyy_internal.cppyy_static_cast
-reinterpret_cast = cppyy.gbl.__cppyy_internal.cppyy_reinterpret_cast
-dynamic_cast     = cppyy.gbl.__cppyy_internal.cppyy_dynamic_cast
+cast             = cppjit.gbl.__cppjit_internal.cppjit_cast
+static_cast      = cppjit.gbl.__cppjit_internal.cppjit_static_cast
+reinterpret_cast = cppjit.gbl.__cppjit_internal.cppjit_reinterpret_cast
+dynamic_cast     = cppjit.gbl.__cppjit_internal.cppjit_dynamic_cast
 
 # import memory allocation/free-ing helpers
-malloc           = CArraySizer(cppyy.gbl.__cppyy_internal.cppyy_malloc)
-free             = cppyy.gbl.free      # for symmetry
-array_new        = ArraySizer(cppyy.gbl.__cppyy_internal.cppyy_array_new)
-array_delete     = cppyy.gbl.__cppyy_internal.cppyy_array_delete
+malloc           = CArraySizer(cppjit.gbl.__cppjit_internal.cppjit_malloc)
+free             = cppjit.gbl.free      # for symmetry
+array_new        = ArraySizer(cppjit.gbl.__cppjit_internal.cppjit_array_new)
+array_delete     = cppjit.gbl.__cppjit_internal.cppjit_array_delete
 
 # signals as exceptions
 if not ispypy:
-    FatalError            = cppyy._backend.FatalError
-    BusError              = cppyy._backend.BusError
-    SegmentationViolation = cppyy._backend.SegmentationViolation
-    IllegalInstruction    = cppyy._backend.IllegalInstruction
-    AbortSignal           = cppyy._backend.AbortSignal
+    FatalError            = cppjit._backend.FatalError
+    BusError              = cppjit._backend.BusError
+    SegmentationViolation = cppjit._backend.SegmentationViolation
+    IllegalInstruction    = cppjit._backend.IllegalInstruction
+    AbortSignal           = cppjit._backend.AbortSignal
 
     class signals_as_exception:
         def __enter__(self):
-            cppyy._backend.SetGlobalSignalPolicy(1)
+            cppjit._backend.SetGlobalSignalPolicy(1)
 
         def __exit__(self, type, value, traceback):
-            cppyy._backend.SetGlobalSignalPolicy(0)
+            cppjit._backend.SetGlobalSignalPolicy(0)
 
-    set_signals_as_exception = cppyy._backend.SetGlobalSignalPolicy
+    set_signals_as_exception = cppjit._backend.SetGlobalSignalPolicy
 
 else:
     class FatalError(Exception):
diff --git a/python/cppjit/cppyy/numba_ext.py b/python/cppjit/numba_ext.py
similarity index 97%
rename from python/cppjit/cppyy/numba_ext.py
rename to python/cppjit/numba_ext.py
index e5d5f9a..7f8b651 100644
--- a/python/cppjit/cppyy/numba_ext.py
+++ b/python/cppjit/numba_ext.py
@@ -1,9 +1,9 @@
-""" cppyy extensions for numba
+""" cppjit extensions for numba
 """
 
-from cppjit import cppyy
-from cppjit.cppyy import types as cpp_types
-from cppjit.cppyy import reflex as cpp_refl
+import cppjit
+import cppjit.types as cpp_types
+import cppjit.reflex as cpp_refl
 
 import numba
 import numba.extending as nb_ext
@@ -32,11 +32,11 @@ class Qualified:
 ir_byte     = ir.IntType(8)
 ir_voidptr  = ir.PointerType(ir_byte)                 # by convention
 ir_byteptr  = ir_voidptr                              # for clarity
-ir_intptr_t = ir.IntType(cppyy.sizeof('void*')*8)
+ir_intptr_t = ir.IntType(cppjit.sizeof('void*')*8)
 
 # special case access to unboxing/boxing APIs
-cppyy_as_voidptr   = cppyy.addressof('Instance_AsVoidPtr')
-cppyy_from_voidptr = cppyy.addressof('Instance_FromVoidPtr')
+cppjit_as_voidptr   = cppjit.addressof('Instance_AsVoidPtr')
+cppjit_from_voidptr = cppjit.addressof('Instance_FromVoidPtr')
 
 
 _cpp2numba = {
@@ -244,7 +244,7 @@ def get_pointer(self, func):
 
         ol = func.__overload__(numba_arg_convertor(self.sig.args))
 
-        address = cppyy.addressof(ol)
+        address = cppjit.addressof(ol)
         if not address:
             raise RuntimeError("unresolved address for %s" % str(ol))
         return address
@@ -300,7 +300,7 @@ def __init__(self, scope, qualifier):
         addr = None
         cppinstance_val = None
         if qualifier == Qualified.instance:
-            addr = cppyy.addressof(scope)
+            addr = cppjit.addressof(scope)
             cppinstance_val = scope
             scope = type(scope)
             qualifier = Qualified.default
@@ -571,7 +571,7 @@ class ImplClassModel(ImplAggregateValueModel):
             class ImplClassModel(ImplClassValueModel):
                 pass
 
-        def init(self, dmm, fe_type, sz = cppyy.sizeof(val)):
+        def init(self, dmm, fe_type, sz = cppjit.sizeof(val)):
             self._data_members = data_members
             self._member_methods = member_methods
             self._sizeof = sz
@@ -589,10 +589,10 @@ def init(self, dmm, fe_type, sz = cppyy.sizeof(val)):
   # Python proxy unwrapping for arguments into the Numba trace
     @nb_ext.unbox(ImplClassType)
     def unbox_instance(typ, obj, c):
-        global cppyy_as_voidptr
+        global cppjit_as_voidptr
 
         ptrty = ir.PointerType(ir.FunctionType(ir_voidptr, [ir_voidptr]))
-        ptrval = c.context.add_dynamic_addr(c.builder, cppyy_as_voidptr, info='Instance_AsVoidPtr')
+        ptrval = c.context.add_dynamic_addr(c.builder, cppjit_as_voidptr, info='Instance_AsVoidPtr')
         fp = c.builder.bitcast(ptrval, ptrty)
 
         vptr = c.context.call_function_pointer(c.builder, fp, [obj])
@@ -609,7 +609,7 @@ def make_implclass(context, builder, typ, **kwargs):
     def box_instance(typ, val, c):
         assert not "requires object model and passing of intact object, not memberwise copy"
 
-        global cppyy_from_voidptr
+        global cppjit_from_voidptr
 
         if isinstance(val, ir.Constant):
             if val.constant == ir.Undefined:
diff --git a/python/cppjit/reflex.py b/python/cppjit/reflex.py
new file mode 100644
index 0000000..eb57446
--- /dev/null
+++ b/python/cppjit/reflex.py
@@ -0,0 +1,28 @@
+""" cppjit reflection
+"""
+
+import cppjit
+
+try:
+    import __pypy__
+    __all__ = [
+
+    ]
+
+except ImportError:
+    __all__ = [
+       'RETURN_TYPE',
+    ]
+
+    cppjit.include("cpyrt/Reflex.h")
+
+    IS_NAMESPACE   = cppjit.gbl.cppjit.interop.Reflex.IS_NAMESPACE
+    IS_AGGREGATE   = cppjit.gbl.cppjit.interop.Reflex.IS_AGGREGATE
+
+    OFFSET         = cppjit.gbl.cppjit.interop.Reflex.OFFSET
+    RETURN_TYPE    = cppjit.gbl.cppjit.interop.Reflex.RETURN_TYPE
+    TYPE           = cppjit.gbl.cppjit.interop.Reflex.TYPE
+
+    OPTIMAL        = cppjit.gbl.cppjit.interop.Reflex.OPTIMAL
+    AS_TYPE        = cppjit.gbl.cppjit.interop.Reflex.AS_TYPE
+    AS_STRING      = cppjit.gbl.cppjit.interop.Reflex.AS_STRING
diff --git a/python/cppjit/cppyy/types.py b/python/cppjit/types.py
similarity index 93%
rename from python/cppjit/cppyy/types.py
rename to python/cppjit/types.py
index 5055cf6..b04a3f5 100644
--- a/python/cppjit/cppyy/types.py
+++ b/python/cppjit/types.py
@@ -1,9 +1,9 @@
 """ C++ proxy types.
 """
 
-from cppjit import cppyy
+import cppjit
 
-bck = cppyy._backend
+bck = cppjit._backend
 Instance      = bck.CPPInstance
 
 try:
diff --git a/python/cppjit/cppyy_backend/__init__.py b/python/cppjit_backend/__init__.py
similarity index 100%
rename from python/cppjit/cppyy_backend/__init__.py
rename to python/cppjit_backend/__init__.py
diff --git a/python/cppjit/cppyy_backend/_cling_config.py b/python/cppjit_backend/_cling_config.py
similarity index 100%
rename from python/cppjit/cppyy_backend/_cling_config.py
rename to python/cppjit_backend/_cling_config.py
diff --git a/python/cppjit/cppyy_backend/_version.py b/python/cppjit_backend/_version.py
similarity index 100%
rename from python/cppjit/cppyy_backend/_version.py
rename to python/cppjit_backend/_version.py
diff --git a/python/cppjit/cppyy_backend/loader.py b/python/cppjit_backend/loader.py
similarity index 95%
rename from python/cppjit/cppyy_backend/loader.py
rename to python/cppjit_backend/loader.py
index c8f79d9..f24cb92 100644
--- a/python/cppjit/cppyy_backend/loader.py
+++ b/python/cppjit_backend/loader.py
@@ -1,9 +1,9 @@
 from __future__ import print_function
-""" cppyy_backend loader
+""" cppjit_backend loader
 """
 
 __all__ = [
-    'load_cpp_backend',           # load libcppyy_backend
+    'load_cpp_backend',           # load libcppjit_backend
     'set_cling_compile_options',  # set EXTRA_CLING_ARGS envar
     'ensure_precompiled_header'   # build precompiled header as necessary
 ]
@@ -75,16 +75,16 @@ def load_cpp_backend():
 
     names = list()
     try:
-        bkname = os.environ['CPPYY_BACKEND_LIBRARY']
+        bkname = os.environ['CPPJIT_BACKEND_LIBRARY']
         if bkname.rfind(soext) < 0:
             bkname += soext
         names.append(bkname)
     except KeyError:
-        names.append('libcppyy-backend'+soext)
+        names.append('libcppjit-backend'+soext)
         if soabi:
-            names.append('libcppyy-backend.'+soabi+soext)
+            names.append('libcppjit-backend.'+soabi+soext)
         if soext2:
-            names.append('libcppyy-backend'+soext2)
+            names.append('libcppjit-backend'+soext2)
 
     err = set()
     for name in names:
@@ -94,7 +94,7 @@ def load_cpp_backend():
         err = err.union(err2)
 
     if not c:
-        raise RuntimeError("could not load cppyy_backend library, details:\n%s" %
+        raise RuntimeError("could not load cppjit_backend library, details:\n%s" %
             '\n'.join(['  '+x for x in err]))
 
     return c
diff --git a/src/CPyCppyy/include/CPyCppyy/CommonDefs.h b/src/CPyCppyy/include/CPyCppyy/CommonDefs.h
deleted file mode 100644
index af2fa60..0000000
--- a/src/CPyCppyy/include/CPyCppyy/CommonDefs.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef CPYCPPYY_COMMONDEFS_H
-#define CPYCPPYY_COMMONDEFS_H
-
-// export macros for our own API
-// import/export (after precommondefs.h from PyPy)
-#ifdef _MSC_VER
-// Windows requires symbols to be explicitly exported
-#define CPYCPPYY_EXPORT extern __declspec(dllexport)
-#define CPYCPPYY_IMPORT extern __declspec(dllimport)
-#define CPYCPPYY_CLASS_EXPORT __declspec(dllexport)
-
-// CPYCPPYY_EXTERN is dual use in the public API
-#ifndef CPYCPPYY_INTERNAL
-#define CPYCPPYY_EXTERN extern __declspec(dllexport)
-#define CPYCPPYY_CLASS_EXTERN __declspec(dllexport)
-#else
-#define CPYCPPYY_EXTERN extern __declspec(dllimport)
-#define CPYCPPYY_CLASS_EXTERN __declspec(dllimport)
-#endif
-
-#define CPYCPPYY_STATIC
-
-#else
-// Linux, Mac, etc.
-#define CPYCPPYY_EXPORT extern
-#define CPYCPPYY_IMPORT extern
-#define CPYCPPYY_CLASS_EXPORT
-#define CPYCPPYY_EXTERN extern
-#define CPYCPPYY_CLASS_EXTERN
-#define CPYCPPYY_STATIC static
-
-#endif
-
-#endif // !CPYCPPYY_COMMONDEFS_H
diff --git a/src/CPyCppyy/src/CPPOperator.h b/src/CPyCppyy/src/CPPOperator.h
deleted file mode 100644
index e260267..0000000
--- a/src/CPyCppyy/src/CPPOperator.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef CPYCPPYY_CPPOPERATOR_H
-#define CPYCPPYY_CPPOPERATOR_H
-
-// Bindings
-#include "CPPMethod.h"
-
-// Standard
-#include <string>
-
-
-namespace CPyCppyy {
-
-class CPPOperator : public CPPMethod {
-public:
-    CPPOperator(Cppyy::TCppScope_t scope, Cppyy::TCppMethod_t method, const std::string& name);
-
-public:
-    PyCallable* Clone() override { return new CPPOperator(*this); }
-    PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
-
-private:
-    binaryfunc fStub;
-};
-
-} // namespace CPyCppyy
-
-#endif // !CPYCPPYY_CPPOPERATOR_H
diff --git a/src/CPyCppyy/src/DeclareExecutors.h b/src/CPyCppyy/src/DeclareExecutors.h
deleted file mode 100644
index 19dea66..0000000
--- a/src/CPyCppyy/src/DeclareExecutors.h
+++ /dev/null
@@ -1,204 +0,0 @@
-#ifndef CPYCPPYY_DECLAREEXECUTORS_H
-#define CPYCPPYY_DECLAREEXECUTORS_H
-
-#include "Python.h"
-#include "Cppyy.h"
-
-// Bindings
-#include "Executors.h"
-#include "CallContext.h"
-#include "Dimensions.h"
-
-// Standard
-#include <cstddef>
-
-
-namespace CPyCppyy {
-
-namespace {
-
-#define CPPYY_DECL_EXEC(name)                                                \
-class name##Executor : public Executor {                                     \
-public:                                                                      \
-    PyObject* Execute(                                                       \
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;    \
-}
-
-// executors for built-ins
-CPPYY_DECL_EXEC(Bool);
-CPPYY_DECL_EXEC(BoolConstRef);
-CPPYY_DECL_EXEC(Char);
-CPPYY_DECL_EXEC(CharConstRef);
-CPPYY_DECL_EXEC(UChar);
-CPPYY_DECL_EXEC(UCharConstRef);
-CPPYY_DECL_EXEC(WChar);
-CPPYY_DECL_EXEC(Char16);
-CPPYY_DECL_EXEC(Char32);
-CPPYY_DECL_EXEC(Int8);
-CPPYY_DECL_EXEC(Int8ConstRef);
-CPPYY_DECL_EXEC(UInt8);
-CPPYY_DECL_EXEC(UInt8ConstRef);
-CPPYY_DECL_EXEC(Short);
-CPPYY_DECL_EXEC(Int);
-CPPYY_DECL_EXEC(Long);
-CPPYY_DECL_EXEC(ULong);
-CPPYY_DECL_EXEC(LongLong);
-CPPYY_DECL_EXEC(ULongLong);
-CPPYY_DECL_EXEC(Float);
-CPPYY_DECL_EXEC(Double);
-CPPYY_DECL_EXEC(LongDouble);
-CPPYY_DECL_EXEC(Void);
-CPPYY_DECL_EXEC(CString);
-CPPYY_DECL_EXEC(CStringRef);
-CPPYY_DECL_EXEC(WCString);
-CPPYY_DECL_EXEC(CString16);
-CPPYY_DECL_EXEC(CString32);
-
-// pointer/array executors
-#define CPPYY_ARRAY_DECL_EXEC(name)                                          \
-class name##ArrayExecutor : public Executor {                                \
-    dims_t fShape;                                                           \
-public:                                                                      \
-    name##ArrayExecutor(dims_t dims) : fShape(dims) {}                       \
-    PyObject* Execute(                                                       \
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;    \
-    bool HasState() override { return true; }                                \
-}
-CPPYY_ARRAY_DECL_EXEC(Void);
-CPPYY_ARRAY_DECL_EXEC(Bool);
-CPPYY_ARRAY_DECL_EXEC(SChar);
-CPPYY_ARRAY_DECL_EXEC(UChar);
-CPPYY_ARRAY_DECL_EXEC(Byte);
-CPPYY_ARRAY_DECL_EXEC(Int8);
-CPPYY_ARRAY_DECL_EXEC(UInt8);
-CPPYY_ARRAY_DECL_EXEC(Short);
-CPPYY_ARRAY_DECL_EXEC(UShort);
-CPPYY_ARRAY_DECL_EXEC(Int);
-CPPYY_ARRAY_DECL_EXEC(UInt);
-CPPYY_ARRAY_DECL_EXEC(Long);
-CPPYY_ARRAY_DECL_EXEC(ULong);
-CPPYY_ARRAY_DECL_EXEC(LLong);
-CPPYY_ARRAY_DECL_EXEC(ULLong);
-CPPYY_ARRAY_DECL_EXEC(Float);
-CPPYY_ARRAY_DECL_EXEC(Double);
-CPPYY_ARRAY_DECL_EXEC(LDouble);
-CPPYY_ARRAY_DECL_EXEC(ComplexF);
-CPPYY_ARRAY_DECL_EXEC(ComplexD);
-CPPYY_ARRAY_DECL_EXEC(ComplexI);
-CPPYY_ARRAY_DECL_EXEC(ComplexL);
-
-// special cases
-CPPYY_DECL_EXEC(ComplexD);
-CPPYY_DECL_EXEC(STLString);
-CPPYY_DECL_EXEC(STLWString);
-
-class InstancePtrExecutor : public Executor {
-public:
-    InstancePtrExecutor(Cppyy::TCppScope_t klass) : fClass(klass) {}
-    PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;
-    bool HasState() override { return true; }
-
-protected:
-    Cppyy::TCppScope_t fClass;
-};
-
-class InstanceExecutor : public Executor {
-public:
-    InstanceExecutor(Cppyy::TCppScope_t klass);
-    PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;
-    bool HasState() override { return true; }
-
-protected:
-    Cppyy::TCppScope_t fClass;
-    uint32_t           fFlags;
-};
-
-class IteratorExecutor : public InstanceExecutor {
-public:
-    IteratorExecutor(Cppyy::TCppScope_t klass);
-};
-
-CPPYY_DECL_EXEC(Constructor);
-CPPYY_DECL_EXEC(PyObject);
-
-#define CPPYY_DECL_REFEXEC(name)                                             \
-class name##RefExecutor : public RefExecutor {                               \
-public:                                                                      \
-    PyObject* Execute(                                                       \
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;    \
-}
-
-CPPYY_DECL_REFEXEC(Bool);
-CPPYY_DECL_REFEXEC(Char);
-CPPYY_DECL_REFEXEC(UChar);
-CPPYY_DECL_REFEXEC(Int8);
-CPPYY_DECL_REFEXEC(UInt8);
-CPPYY_DECL_REFEXEC(Short);
-CPPYY_DECL_REFEXEC(UShort);
-CPPYY_DECL_REFEXEC(Int);
-CPPYY_DECL_REFEXEC(UInt);
-CPPYY_DECL_REFEXEC(Long);
-CPPYY_DECL_REFEXEC(ULong);
-CPPYY_DECL_REFEXEC(LongLong);
-CPPYY_DECL_REFEXEC(ULongLong);
-CPPYY_DECL_REFEXEC(Float);
-CPPYY_DECL_REFEXEC(Double);
-CPPYY_DECL_REFEXEC(LongDouble);
-CPPYY_DECL_REFEXEC(ComplexD);
-CPPYY_DECL_REFEXEC(STLString);
-
-// special cases
-class InstanceRefExecutor : public RefExecutor {
-public:
-    InstanceRefExecutor(Cppyy::TCppScope_t klass) : fClass(klass) {}
-    PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;
-
-protected:
-    Cppyy::TCppScope_t fClass;
-};
-
-class InstancePtrPtrExecutor : public InstanceRefExecutor {
-public:
-    using InstanceRefExecutor::InstanceRefExecutor;
-    PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;
-};
-
-class InstancePtrRefExecutor : public InstanceRefExecutor {
-public:
-    using InstanceRefExecutor::InstanceRefExecutor;
-    PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;
-};
-
-class InstanceArrayExecutor : public InstancePtrExecutor {
-public:
-    InstanceArrayExecutor(Cppyy::TCppScope_t klass, dim_t array_size)
-        : InstancePtrExecutor(klass), fSize(array_size) {}
-    PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;
-
-protected:
-    dim_t fSize;
-};
-
-class FunctionPointerExecutor : public Executor {
-public:
-    FunctionPointerExecutor(const std::string& ret, const std::string& sig) :
-        fRetType(ret), fSignature(sig) {}
-    PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) override;
-
-protected:
-    std::string fRetType;
-    std::string fSignature;
-};
-
-} // unnamed namespace
-
-} // namespace CPyCppyy
-
-#endif // !CPYCPPYY_DECLAREEXECUTORS_H
diff --git a/src/CPyCppyy/src/Executors.h b/src/CPyCppyy/src/Executors.h
deleted file mode 100644
index c081a43..0000000
--- a/src/CPyCppyy/src/Executors.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef CPYCPPYY_EXECUTORS_H
-#define CPYCPPYY_EXECUTORS_H
-
-#include "Python.h"
-#include "Cppyy.h"
-
-// Bindings
-#include "Dimensions.h"
-
-// Standard
-#include <string>
-
-
-namespace CPyCppyy {
-
-struct CallContext;
-
-class CPYCPPYY_CLASS_EXPORT Executor {
-public:
-    virtual ~Executor();
-    virtual PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) = 0;
-    virtual bool HasState() { return false; }
-};
-
-// special case needed for CPPSetItem
-class RefExecutor : public Executor {
-public:
-    RefExecutor() : fAssignable(nullptr) {}
-    virtual bool SetAssignable(PyObject*);
-    bool HasState() override { return true; }
-
-protected:
-    PyObject* fAssignable;
-};
-
-// create/destroy executor from fully qualified type (public API)
-CPYCPPYY_EXPORT Executor* CreateExecutor(const std::string& fullType, cdims_t = 0);
-CPYCPPYY_EXPORT Executor* CreateExecutor(Cppyy::TCppType_t type, cdims_t = 0);
-CPYCPPYY_EXPORT void DestroyExecutor(Executor* p);
-typedef Executor* (*ef_t) (cdims_t);
-CPYCPPYY_EXPORT bool RegisterExecutor(const std::string& name, ef_t fac);
-CPYCPPYY_EXPORT bool RegisterExecutorAlias(const std::string& name, const std::string& target);
-CPYCPPYY_EXPORT bool UnregisterExecutor(const std::string& name);
-
-// helper for the actual call
-CPYCPPYY_EXPORT void* CallVoidP(Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*);
-
-} // namespace CPyCppyy
-
-#endif // !CPYCPPYY_EXECUTORS_H
diff --git a/src/CPyCppyy/src/ProxyWrappers.h b/src/CPyCppyy/src/ProxyWrappers.h
deleted file mode 100644
index 7a074f8..0000000
--- a/src/CPyCppyy/src/ProxyWrappers.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef CPYCPPYY_PROXYWRAPPERS_H
-#define CPYCPPYY_PROXYWRAPPERS_H
-
-// Bindings
-#include "Dimensions.h"
-
-// Standard
-#include <string>
-
-
-namespace CPyCppyy {
-
-// construct a Python shadow class for the named C++ class
-PyObject* GetScopeProxy(Cppyy::TCppScope_t);
-PyObject* CreateScopeProxy(PyObject*, PyObject* args);
-PyObject* CreateScopeProxy(
-    const std::string& scope_name, PyObject* parent = nullptr, const unsigned flags = 0);
-
-PyObject* CreateScopeProxy(Cppyy::TCppScope_t scope, PyObject* parent = nullptr, const unsigned flags = 0);
-// C++ exceptions form a special case b/c they have to derive from BaseException
-PyObject* CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyObject* parent);
-
-// bind a C++ object into a Python proxy object (flags are CPPInstance::Default)
-PyObject* BindCppObjectNoCast(Cppyy::TCppObject_t object,
-    Cppyy::TCppScope_t klass, const unsigned flags = 0);
-PyObject* BindCppObject(Cppyy::TCppObject_t object,
-    Cppyy::TCppScope_t klass, const unsigned flags = 0);
-PyObject* BindCppObjectArray(
-    Cppyy::TCppObject_t address, Cppyy::TCppScope_t klass, cdims_t dims);
-
-} // namespace CPyCppyy
-
-#endif // !CPYCPPYY_PROXYWRAPPERS_H
diff --git a/src/CPyCppyy/src/PyStrings.cxx b/src/CPyCppyy/src/PyStrings.cxx
deleted file mode 100644
index 7142d24..0000000
--- a/src/CPyCppyy/src/PyStrings.cxx
+++ /dev/null
@@ -1,241 +0,0 @@
-// Bindings
-#include "CPyCppyy.h"
-#include "PyStrings.h"
-
-
-//- data _____________________________________________________________________
-PyObject* CPyCppyy::PyStrings::gAssign           = nullptr;
-PyObject* CPyCppyy::PyStrings::gBases            = nullptr;
-PyObject* CPyCppyy::PyStrings::gBase             = nullptr;
-PyObject* CPyCppyy::PyStrings::gContains         = nullptr;
-PyObject* CPyCppyy::PyStrings::gCopy             = nullptr;
-PyObject* CPyCppyy::PyStrings::gCppBool          = nullptr;
-PyObject* CPyCppyy::PyStrings::gCppName          = nullptr;
-PyObject* CPyCppyy::PyStrings::gAnnotations      = nullptr;
-PyObject* CPyCppyy::PyStrings::gCastCpp          = nullptr;
-PyObject* CPyCppyy::PyStrings::gCType            = nullptr;
-PyObject* CPyCppyy::PyStrings::gDeref            = nullptr;
-PyObject* CPyCppyy::PyStrings::gPreInc           = nullptr;
-PyObject* CPyCppyy::PyStrings::gPostInc          = nullptr;
-PyObject* CPyCppyy::PyStrings::gDict             = nullptr;
-PyObject* CPyCppyy::PyStrings::gEmptyString      = nullptr;
-PyObject* CPyCppyy::PyStrings::gEq               = nullptr;
-PyObject* CPyCppyy::PyStrings::gFollow           = nullptr;
-PyObject* CPyCppyy::PyStrings::gGetItem          = nullptr;
-PyObject* CPyCppyy::PyStrings::gGetNoCheck       = nullptr;
-PyObject* CPyCppyy::PyStrings::gSetItem          = nullptr;
-PyObject* CPyCppyy::PyStrings::gInit             = nullptr;
-PyObject* CPyCppyy::PyStrings::gIter             = nullptr;
-PyObject* CPyCppyy::PyStrings::gLen              = nullptr;
-PyObject* CPyCppyy::PyStrings::gLifeLine         = nullptr;
-PyObject* CPyCppyy::PyStrings::gModule           = nullptr;
-PyObject* CPyCppyy::PyStrings::gMRO              = nullptr;
-PyObject* CPyCppyy::PyStrings::gName             = nullptr;
-PyObject* CPyCppyy::PyStrings::gNe               = nullptr;
-PyObject* CPyCppyy::PyStrings::gRepr             = nullptr;
-PyObject* CPyCppyy::PyStrings::gCppRepr          = nullptr;
-PyObject* CPyCppyy::PyStrings::gStr              = nullptr;
-PyObject* CPyCppyy::PyStrings::gCppStr           = nullptr;
-PyObject* CPyCppyy::PyStrings::gTypeCode         = nullptr;
-PyObject* CPyCppyy::PyStrings::gCTypesType       = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gUnderlying       = nullptr;
-PyObject* CPyCppyy::PyStrings::gRealInit         = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gAdd              = nullptr;
-PyObject* CPyCppyy::PyStrings::gSub              = nullptr;
-PyObject* CPyCppyy::PyStrings::gMul              = nullptr;
-PyObject* CPyCppyy::PyStrings::gDiv              = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gLShift           = nullptr;
-PyObject* CPyCppyy::PyStrings::gLShiftC          = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gAt               = nullptr;
-PyObject* CPyCppyy::PyStrings::gBegin            = nullptr;
-PyObject* CPyCppyy::PyStrings::gEnd              = nullptr;
-PyObject* CPyCppyy::PyStrings::gFirst            = nullptr;
-PyObject* CPyCppyy::PyStrings::gSecond           = nullptr;
-PyObject* CPyCppyy::PyStrings::gSize             = nullptr;
-PyObject* CPyCppyy::PyStrings::gTemplate         = nullptr;
-PyObject* CPyCppyy::PyStrings::gVectorAt         = nullptr;
-PyObject* CPyCppyy::PyStrings::gInsert           = nullptr;
-PyObject* CPyCppyy::PyStrings::gValueType        = nullptr;
-PyObject* CPyCppyy::PyStrings::gValueTypePtr     = nullptr;
-PyObject* CPyCppyy::PyStrings::gValueSize        = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gCppReal          = nullptr;
-PyObject* CPyCppyy::PyStrings::gCppImag          = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gThisModule       = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gDispInit         = nullptr;
-PyObject* CPyCppyy::PyStrings::gDispGet          = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gExPythonize      = nullptr;
-PyObject* CPyCppyy::PyStrings::gPythonize        = nullptr;
-
-PyObject* CPyCppyy::PyStrings::gArray            = nullptr;
-PyObject* CPyCppyy::PyStrings::gDType            = nullptr;
-PyObject* CPyCppyy::PyStrings::gFromBuffer       = nullptr;
-
-
-//-----------------------------------------------------------------------------
-#define CPPYY_INITIALIZE_STRING(var, str)                                     \
-    if (!(PyStrings::var = CPyCppyy_PyText_InternFromString((char*)#str)))    \
-        return false
-
-bool CPyCppyy::CreatePyStrings() {
-// Build cache of commonly used python strings (the cache is python intern, so
-// all strings are shared python-wide, not just in cppyy).
-    CPPYY_INITIALIZE_STRING(gAssign,         __assign__);
-    CPPYY_INITIALIZE_STRING(gBases,          __bases__);
-    CPPYY_INITIALIZE_STRING(gBase,           __base__);
-    CPPYY_INITIALIZE_STRING(gContains,       contains);
-    CPPYY_INITIALIZE_STRING(gCopy,           copy);
-    CPPYY_INITIALIZE_STRING(gCppBool,        __cpp_bool__);
-    CPPYY_INITIALIZE_STRING(gCppName,        __cpp_name__);
-    CPPYY_INITIALIZE_STRING(gAnnotations,    __annotations__);
-    CPPYY_INITIALIZE_STRING(gCastCpp,        __cast_cpp__);
-    CPPYY_INITIALIZE_STRING(gCType,          __ctype__);
-    CPPYY_INITIALIZE_STRING(gDeref,          __deref__);
-    CPPYY_INITIALIZE_STRING(gPreInc,         __preinc__);
-    CPPYY_INITIALIZE_STRING(gPostInc,        __postinc__);
-    CPPYY_INITIALIZE_STRING(gDict,           __dict__);
-    if (!(PyStrings::gEmptyString = CPyCppyy_PyText_FromString((char*)"")))
-        return false;
-    CPPYY_INITIALIZE_STRING(gEq,             __eq__);
-    CPPYY_INITIALIZE_STRING(gFollow,         __follow__);
-    CPPYY_INITIALIZE_STRING(gGetItem,        __getitem__);
-    CPPYY_INITIALIZE_STRING(gGetNoCheck,     _getitem__unchecked);
-    CPPYY_INITIALIZE_STRING(gSetItem,        __setitem__);
-    CPPYY_INITIALIZE_STRING(gInit,           __init__);
-    CPPYY_INITIALIZE_STRING(gIter,           __iter__);
-    CPPYY_INITIALIZE_STRING(gLen,            __len__);
-    CPPYY_INITIALIZE_STRING(gLifeLine,       __lifeline);
-    CPPYY_INITIALIZE_STRING(gModule,         __module__);
-    CPPYY_INITIALIZE_STRING(gMRO,            __mro__);
-    CPPYY_INITIALIZE_STRING(gName,           __name__);
-    CPPYY_INITIALIZE_STRING(gNe,             __ne__);
-    CPPYY_INITIALIZE_STRING(gRepr,           __repr__);
-    CPPYY_INITIALIZE_STRING(gCppRepr,        __cpp_repr);
-    CPPYY_INITIALIZE_STRING(gStr,            __str__);
-    CPPYY_INITIALIZE_STRING(gCppStr,         __cpp_str);
-    CPPYY_INITIALIZE_STRING(gTypeCode,       typecode);
-    CPPYY_INITIALIZE_STRING(gCTypesType,     _type_);
-
-    CPPYY_INITIALIZE_STRING(gUnderlying,     __underlying);
-    CPPYY_INITIALIZE_STRING(gRealInit,       __real_init);
-
-    CPPYY_INITIALIZE_STRING(gAdd,            __add__);
-    CPPYY_INITIALIZE_STRING(gSub,            __sub__);
-    CPPYY_INITIALIZE_STRING(gMul,            __mul__);
-    CPPYY_INITIALIZE_STRING(gDiv,            CPPYY__div__);
-
-    CPPYY_INITIALIZE_STRING(gLShift,         __lshift__);
-    CPPYY_INITIALIZE_STRING(gLShiftC,        __lshiftc__);
-
-    CPPYY_INITIALIZE_STRING(gAt,             at);
-    CPPYY_INITIALIZE_STRING(gBegin,          begin);
-    CPPYY_INITIALIZE_STRING(gEnd,            end);
-    CPPYY_INITIALIZE_STRING(gFirst,          first);
-    CPPYY_INITIALIZE_STRING(gSecond,         second);
-    CPPYY_INITIALIZE_STRING(gSize,           size);
-    CPPYY_INITIALIZE_STRING(gTemplate,       Template);
-    CPPYY_INITIALIZE_STRING(gVectorAt,       _vector__at);
-    CPPYY_INITIALIZE_STRING(gInsert,         insert);
-    CPPYY_INITIALIZE_STRING(gValueType,      value_type);
-    CPPYY_INITIALIZE_STRING(gValueTypePtr,   _value_type);
-    CPPYY_INITIALIZE_STRING(gValueSize,      value_size);
-
-    CPPYY_INITIALIZE_STRING(gCppReal,        __cpp_real);
-    CPPYY_INITIALIZE_STRING(gCppImag,        __cpp_imag);
-
-    CPPYY_INITIALIZE_STRING(gThisModule,     cppyy);
-
-    CPPYY_INITIALIZE_STRING(gDispInit,       _init_dispatchptr);
-    CPPYY_INITIALIZE_STRING(gDispGet,        _get_dispatch);
-
-    CPPYY_INITIALIZE_STRING(gExPythonize,    __cppyy_explicit_pythonize__);
-    CPPYY_INITIALIZE_STRING(gPythonize,      __cppyy_pythonize__);
-
-    CPPYY_INITIALIZE_STRING(gArray,          __array__);
-    CPPYY_INITIALIZE_STRING(gDType,          dtype);
-    CPPYY_INITIALIZE_STRING(gFromBuffer,     frombuffer);
-
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-PyObject* CPyCppyy::DestroyPyStrings() {
-// Remove all cached python strings.
-    Py_DECREF(PyStrings::gBases);       PyStrings::gBases       = nullptr;
-    Py_DECREF(PyStrings::gBase);        PyStrings::gBase        = nullptr;
-    Py_DECREF(PyStrings::gContains);    PyStrings::gContains    = nullptr;
-    Py_DECREF(PyStrings::gCopy);        PyStrings::gCopy        = nullptr;
-    Py_DECREF(PyStrings::gCppBool);     PyStrings::gCppBool     = nullptr;
-    Py_DECREF(PyStrings::gCppName);     PyStrings::gCppName     = nullptr;
-    Py_DECREF(PyStrings::gAnnotations); PyStrings::gAnnotations = nullptr;
-    Py_DECREF(PyStrings::gCType);       PyStrings::gCType       = nullptr;
-    Py_DECREF(PyStrings::gDeref);       PyStrings::gDeref       = nullptr;
-    Py_DECREF(PyStrings::gPreInc);      PyStrings::gPreInc      = nullptr;
-    Py_DECREF(PyStrings::gPostInc);     PyStrings::gPostInc     = nullptr;
-    Py_DECREF(PyStrings::gDict);        PyStrings::gDict        = nullptr;
-    Py_DECREF(PyStrings::gEmptyString); PyStrings::gEmptyString = nullptr;
-    Py_DECREF(PyStrings::gEq);          PyStrings::gEq          = nullptr;
-    Py_DECREF(PyStrings::gFollow);      PyStrings::gFollow      = nullptr;
-    Py_DECREF(PyStrings::gGetItem);     PyStrings::gGetItem     = nullptr;
-    Py_DECREF(PyStrings::gGetNoCheck);  PyStrings::gGetNoCheck  = nullptr;
-    Py_DECREF(PyStrings::gSetItem);     PyStrings::gSetItem     = nullptr;
-    Py_DECREF(PyStrings::gInit);        PyStrings::gInit        = nullptr;
-    Py_DECREF(PyStrings::gIter);        PyStrings::gIter        = nullptr;
-    Py_DECREF(PyStrings::gLen);         PyStrings::gLen         = nullptr;
-    Py_DECREF(PyStrings::gLifeLine);    PyStrings::gLifeLine    = nullptr;
-    Py_DECREF(PyStrings::gModule);      PyStrings::gModule      = nullptr;
-    Py_DECREF(PyStrings::gMRO);         PyStrings::gMRO         = nullptr;
-    Py_DECREF(PyStrings::gName);        PyStrings::gName        = nullptr;
-    Py_DECREF(PyStrings::gNe);          PyStrings::gNe          = nullptr;
-    Py_DECREF(PyStrings::gTypeCode);    PyStrings::gTypeCode    = nullptr;
-    Py_DECREF(PyStrings::gCTypesType);  PyStrings::gCTypesType  = nullptr;
-
-    Py_DECREF(PyStrings::gUnderlying);  PyStrings::gUnderlying  = nullptr;
-    Py_DECREF(PyStrings::gRealInit);    PyStrings::gRealInit    = nullptr;
-
-    Py_DECREF(PyStrings::gAdd);         PyStrings::gAdd         = nullptr;
-    Py_DECREF(PyStrings::gSub);         PyStrings::gSub         = nullptr;
-    Py_DECREF(PyStrings::gMul);         PyStrings::gMul         = nullptr;
-    Py_DECREF(PyStrings::gDiv);         PyStrings::gDiv         = nullptr;
-
-    Py_DECREF(PyStrings::gLShift);      PyStrings::gLShift      = nullptr;
-    Py_DECREF(PyStrings::gLShiftC);     PyStrings::gLShiftC     = nullptr;
-
-    Py_DECREF(PyStrings::gAt);          PyStrings::gAt          = nullptr;
-    Py_DECREF(PyStrings::gBegin);       PyStrings::gBegin       = nullptr;
-    Py_DECREF(PyStrings::gEnd);         PyStrings::gEnd         = nullptr;
-    Py_DECREF(PyStrings::gFirst);       PyStrings::gFirst       = nullptr;
-    Py_DECREF(PyStrings::gSecond);      PyStrings::gSecond      = nullptr;
-    Py_DECREF(PyStrings::gSize);        PyStrings::gSize        = nullptr;
-    Py_DECREF(PyStrings::gTemplate);    PyStrings::gTemplate    = nullptr;
-    Py_DECREF(PyStrings::gVectorAt);    PyStrings::gVectorAt    = nullptr;
-    Py_DECREF(PyStrings::gInsert);      PyStrings::gInsert      = nullptr;
-    Py_DECREF(PyStrings::gValueType);   PyStrings::gValueType   = nullptr;
-    Py_DECREF(PyStrings::gValueTypePtr);PyStrings::gValueTypePtr= nullptr;
-    Py_DECREF(PyStrings::gValueSize);   PyStrings::gValueSize   = nullptr;
-
-    Py_DECREF(PyStrings::gCppReal);     PyStrings::gCppReal     = nullptr;
-    Py_DECREF(PyStrings::gCppImag);     PyStrings::gCppImag     = nullptr;
-
-    Py_DECREF(PyStrings::gThisModule);  PyStrings::gThisModule  = nullptr;
-
-    Py_DECREF(PyStrings::gDispInit);    PyStrings::gDispInit    = nullptr;
-    Py_DECREF(PyStrings::gDispGet);     PyStrings::gDispGet     = nullptr;
-
-    Py_DECREF(PyStrings::gExPythonize); PyStrings::gExPythonize = nullptr;
-    Py_DECREF(PyStrings::gPythonize);   PyStrings::gPythonize   = nullptr;
-
-    Py_DECREF(PyStrings::gArray);       PyStrings::gArray       = nullptr;
-    Py_DECREF(PyStrings::gDType);       PyStrings::gDType       = nullptr;
-    Py_DECREF(PyStrings::gFromBuffer);  PyStrings::gFromBuffer  = nullptr;
-
-    Py_RETURN_NONE;
-}
diff --git a/src/CPyCppyy/src/Pythonize.h b/src/CPyCppyy/src/Pythonize.h
deleted file mode 100644
index 673f574..0000000
--- a/src/CPyCppyy/src/Pythonize.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef CPYCPPYY_PYTHONIZE_H
-#define CPYCPPYY_PYTHONIZE_H
-
-// Standard
-#include <string>
-
-
-namespace CPyCppyy {
-
-// make the named C++ class more python-like
-bool Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope);
-
-} // namespace CPyCppyy
-
-#endif // !CPYCPPYY_PYTHONIZE_H
diff --git a/src/backend/callcontext.h b/src/backend/callcontext.h
index b0ae54a..38bf9d8 100644
--- a/src/backend/callcontext.h
+++ b/src/backend/callcontext.h
@@ -1,11 +1,11 @@
-#ifndef CPYCPPYY_CALLCONTEXT_H
-#define CPYCPPYY_CALLCONTEXT_H
+#ifndef CPYRT_CALLCONTEXT_H
+#define CPYRT_CALLCONTEXT_H
 
 // Standard
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 // general place holder for function parameters
     struct Parameter {
@@ -33,6 +33,6 @@ namespace CPyCppyy {
         char  fTypeCode;
     };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CALLCONTEXT_H
+#endif // !CPYRT_CALLCONTEXT_H
diff --git a/src/backend/cpp_cppyy.h b/src/backend/cpp_cppjit.h
similarity index 96%
rename from src/backend/cpp_cppyy.h
rename to src/backend/cpp_cppjit.h
index 8b2bbcf..a215cfd 100644
--- a/src/backend/cpp_cppyy.h
+++ b/src/backend/cpp_cppjit.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_CPPYY_H
-#define CPYCPPYY_CPPYY_H
+#ifndef CPYRT_CPPJIT_H
+#define CPYRT_CPPJIT_H
 
 #include <CppInterOp/CppInterOpTypes.h>
 #include <CppInterOp/Dispatch.h>
@@ -15,7 +15,7 @@
 #include "precommondefs.h"
 #include "callcontext.h"
 
-// some more types; assumes Cppyy.h follows Python.h
+// some more types; assumes cppjit_interop.h follows Python.h
 #ifndef PY_LONG_LONG
 #ifdef _WIN32
 typedef __int64 PY_LONG_LONG;
@@ -36,7 +36,7 @@ typedef unsigned long long PY_ULONG_LONG;
 typedef long double PY_LONG_DOUBLE;
 #endif
 
-typedef CPyCppyy::Parameter Parameter;
+typedef cppjit::cpyrt::Parameter Parameter;
 
 // small number that allows use of stack for argument passing
 const int SMALL_ARGS_N = 8;
@@ -47,7 +47,7 @@ static inline size_t CALL_NARGS(size_t nargs) {
     return nargs & ~DIRECT_CALL;
 }
 
-namespace Cppyy {
+namespace cppjit::interop {
     typedef Cpp::DeclRef TCppScope_t;
     typedef Cpp::TypeRef TCppType_t;
     typedef Cpp::ObjectRef TCppObject_t;
@@ -95,7 +95,7 @@ namespace Cppyy {
     TCppType_t GetType(const std::string &name, bool enable_slow_lookup = false);
     RPY_EXPORTED
     bool AppendTypesSlow(const std::string &name,
-                         std::vector<Cpp::TemplateArgInfo>& types, Cppyy::TCppScope_t parent = nullptr);
+                         std::vector<Cpp::TemplateArgInfo>& types, cppjit::interop::TCppScope_t parent = nullptr);
     RPY_EXPORTED
     TCppType_t GetComplexType(const std::string &element_type);
     RPY_EXPORTED
@@ -221,7 +221,7 @@ namespace Cppyy {
 
 // namespace reflection information ------------------------------------------
     RPY_EXPORTED
-    std::vector<Cppyy::TCppScope_t> GetUsingNamespaces(TCppScope_t);
+    std::vector<cppjit::interop::TCppScope_t> GetUsingNamespaces(TCppScope_t);
 
 // class reflection information ----------------------------------------------
     RPY_EXPORTED
@@ -312,7 +312,7 @@ namespace Cppyy {
     TCppMethod_t GetMethodTemplate(
         TCppScope_t scope, const std::string& name, const std::string& proto);
     RPY_EXPORTED
-    void GetClassOperators(Cppyy::TCppScope_t klass, const std::string& opname,
+    void GetClassOperators(cppjit::interop::TCppScope_t klass, const std::string& opname,
                            std::vector<TCppMethod_t>& operators);
     RPY_EXPORTED
     TCppMethod_t  GetGlobalOperator(
@@ -386,6 +386,6 @@ namespace Cppyy {
 
     RPY_EXPORTED
     void        DumpScope(TCppScope_t scope);
-} // namespace Cppyy
+} // namespace cppjit::interop
 
-#endif // !CPYCPPYY_CPPYY_H
+#endif // !CPYRT_CPPJIT_H
diff --git a/src/backend/clingwrapper.cxx b/src/backend/interop_wrapper.cxx
similarity index 76%
rename from src/backend/clingwrapper.cxx
rename to src/backend/interop_wrapper.cxx
index 4b89dab..046dca0 100644
--- a/src/backend/clingwrapper.cxx
+++ b/src/backend/interop_wrapper.cxx
@@ -9,7 +9,7 @@
 
 
 // Bindings
-#include "cpp_cppyy.h"
+#include "cpp_cppjit.h"
 #include "callcontext.h"
 
 #ifndef _WIN32
@@ -112,14 +112,14 @@ bool is_integral(std::string& s)
 }
 
 class ApplicationStarter {
-  Cppyy::TInterp_t Interp;
+  cppjit::interop::TInterp_t Interp;
 public:
     ApplicationStarter() {
         std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
         if (!Cpp::LoadDispatchAPI(
                 CPPINTEROP_DIR
                 "/lib/libclangCppInterOp" CMAKE_SHARED_LIBRARY_SUFFIX)) {
-            std::cerr << "[cppyy-backend] Failed to load CppInterOp" << std::endl;
+            std::cerr << "[cppjit-backend] Failed to load CppInterOp" << std::endl;
             return;
         }
         // Check if somebody already loaded CppInterOp and created an
@@ -166,12 +166,12 @@ class ApplicationStarter {
         }
 
     // disable fast path if requested
-        if (getenv("CPPYY_DISABLE_FASTPATH")) gEnableFastPath = false;
+        if (getenv("CPPJIT_DISABLE_FASTPATH")) gEnableFastPath = false;
 
     // set opt level (default to 2 if not given; Cling itself defaults to 0)
         int optLevel = 2;
 
-        if (getenv("CPPYY_OPT_LEVEL")) optLevel = atoi(getenv("CPPYY_OPT_LEVEL"));
+        if (getenv("CPPJIT_OPT_LEVEL")) optLevel = atoi(getenv("CPPJIT_OPT_LEVEL"));
 
         if (optLevel != 0) {
             std::ostringstream s;
@@ -220,11 +220,11 @@ class ApplicationStarter {
         Cpp::Process(code);
 
     // create helpers for comparing thingies
-        Cpp::Declare("namespace __cppyy_internal { template<class C1, class C2>"
+        Cpp::Declare("namespace __cppjit_internal { template<class C1, class C2>"
                      " bool is_equal(const C1& c1, const C2& c2) { return "
                      "(bool)(c1 == c2); } }",
                      /*silent=*/false);
-        Cpp::Declare("namespace __cppyy_internal { template<class C1, class C2>"
+        Cpp::Declare("namespace __cppjit_internal { template<class C1, class C2>"
                      " bool is_not_equal(const C1& c1, const C2& c2) { return "
                      "(bool)(c1 != c2); } }",
                      /*silent=*/false);
@@ -241,7 +241,7 @@ class ApplicationStarter {
         Cpp::Process(InterpPtrSS.str().c_str());
 
     // helper for multiple inheritance
-        Cpp::Declare("namespace __cppyy_internal { struct Sep; }",
+        Cpp::Declare("namespace __cppjit_internal { struct Sep; }",
                      /*silent=*/false);
 
         // std::string libInterOp = I->getDynamicLibraryManager()->lookupLibrary("libcling");
@@ -280,14 +280,14 @@ char* cppstring_to_cstring(const std::string& cppstr)
 
 // direct interpreter access -------------------------------------------------
 // Returns false on failure and true on success
-bool Cppyy::Compile(const std::string& code, bool silent)
+bool cppjit::interop::Compile(const std::string& code, bool silent)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     // Declare returns an enum which equals 0 on success
     return !Cpp::Declare(code.c_str(), silent);
 }
 
-std::string Cppyy::ToString(TCppScope_t klass, TCppObject_t obj)
+std::string cppjit::interop::ToString(TCppScope_t klass, TCppObject_t obj)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     if (klass && obj && !Cpp::IsNamespace(klass))
@@ -296,17 +296,17 @@ std::string Cppyy::ToString(TCppScope_t klass, TCppObject_t obj)
 }
 
 // // name to opaque C++ scope representation -----------------------------------
-std::string Cppyy::ResolveName(const std::string& name) {
+std::string cppjit::interop::ResolveName(const std::string& name) {
   if (!name.empty()) {
-    if (Cppyy::TCppType_t type =
-            Cppyy::GetType(name, /*enable_slow_lookup=*/true))
-      return Cppyy::GetTypeAsString(Cppyy::ResolveType(type));
+    if (cppjit::interop::TCppType_t type =
+            cppjit::interop::GetType(name, /*enable_slow_lookup=*/true))
+      return cppjit::interop::GetTypeAsString(cppjit::interop::ResolveType(type));
     return name;
   }
   return "";
 }
 
-Cppyy::TCppType_t Cppyy::ResolveEnumReferenceType(TCppType_t type) {
+cppjit::interop::TCppType_t cppjit::interop::ResolveEnumReferenceType(TCppType_t type) {
 std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     if (Cpp::GetValueKind(type) != Cpp::ValueKind::LValue)
         return type;
@@ -319,7 +319,7 @@ std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return type;
 }
 
-Cppyy::TCppType_t Cppyy::ResolveEnumPointerType(TCppType_t type) {
+cppjit::interop::TCppType_t cppjit::interop::ResolveEnumPointerType(TCppType_t type) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     if (!Cpp::IsPointerType(type))
         return type;
@@ -332,8 +332,8 @@ Cppyy::TCppType_t Cppyy::ResolveEnumPointerType(TCppType_t type) {
     return type;
 }
 
-Cppyy::TCppType_t int_like_type(Cppyy::TCppType_t type) {
-    Cppyy::TCppType_t check_int_typedefs = type;
+cppjit::interop::TCppType_t int_like_type(cppjit::interop::TCppType_t type) {
+    cppjit::interop::TCppType_t check_int_typedefs = type;
     if (Cpp::IsPointerType(check_int_typedefs))
         check_int_typedefs = Cpp::GetPointeeType(check_int_typedefs);
     if (Cpp::IsReferenceType(check_int_typedefs))
@@ -345,7 +345,7 @@ Cppyy::TCppType_t int_like_type(Cppyy::TCppType_t type) {
     return nullptr;
 }
 
-Cppyy::TCppType_t Cppyy::ResolveType(TCppType_t type) {
+cppjit::interop::TCppType_t cppjit::interop::ResolveType(TCppType_t type) {
     if (!type) return type;
 
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
@@ -354,7 +354,7 @@ Cppyy::TCppType_t Cppyy::ResolveType(TCppType_t type) {
     if (check_int_typedefs)
         return type;
 
-    Cppyy::TCppType_t canonType = Cpp::GetCanonicalType(type);
+    cppjit::interop::TCppType_t canonType = Cpp::GetCanonicalType(type);
 
     if (Cpp::IsEnumType(canonType)) {
         if (Cpp::GetTypeAsString(type) != "std::byte")
@@ -367,7 +367,7 @@ Cppyy::TCppType_t Cppyy::ResolveType(TCppType_t type) {
     return canonType;
 }
 
-Cppyy::TCppType_t Cppyy::GetRealType(TCppType_t type) {
+cppjit::interop::TCppType_t cppjit::interop::GetRealType(TCppType_t type) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     TCppType_t check_int_typedefs = int_like_type(type);
     if (check_int_typedefs)
@@ -375,29 +375,29 @@ Cppyy::TCppType_t Cppyy::GetRealType(TCppType_t type) {
     return Cpp::GetUnderlyingType(type);
 }
 
-Cppyy::TCppType_t Cppyy::GetPointerType(TCppType_t type) {
+cppjit::interop::TCppType_t cppjit::interop::GetPointerType(TCppType_t type) {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   return Cpp::GetPointerType(type);
 }
 
-Cppyy::TCppType_t Cppyy::GetReferencedType(TCppType_t type, bool rvalue) {
+cppjit::interop::TCppType_t cppjit::interop::GetReferencedType(TCppType_t type, bool rvalue) {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   return Cpp::GetReferencedType(type, rvalue);
 }
 
-bool Cppyy::IsRValueReferenceType(TCppType_t type) {
+bool cppjit::interop::IsRValueReferenceType(TCppType_t type) {
     return Cpp::GetValueKind(type) == Cpp::ValueKind::RValue;
 }
 
-bool Cppyy::IsLValueReferenceType(TCppType_t type) {
+bool cppjit::interop::IsLValueReferenceType(TCppType_t type) {
     return Cpp::GetValueKind(type) == Cpp::ValueKind::LValue;
 }
 
-bool Cppyy::IsClassType(TCppType_t type) {
+bool cppjit::interop::IsClassType(TCppType_t type) {
     return Cpp::IsRecordType(type);
 }
 
-bool Cppyy::IsIntegerType(TCppType_t type, bool* is_signed /*= nullptr*/) {
+bool cppjit::interop::IsIntegerType(TCppType_t type, bool* is_signed /*= nullptr*/) {
   if (is_signed) {
     Cpp::Signedness sign;
     bool res = Cpp::IsIntegerType(type, &sign);
@@ -407,11 +407,11 @@ bool Cppyy::IsIntegerType(TCppType_t type, bool* is_signed /*= nullptr*/) {
   return Cpp::IsIntegerType(type, nullptr);
 }
 
-bool Cppyy::IsPointerType(TCppType_t type) {
+bool cppjit::interop::IsPointerType(TCppType_t type) {
     return Cpp::IsPointerType(type);
 }
 
-bool Cppyy::IsFunctionPointerType(TCppType_t type) {
+bool cppjit::interop::IsFunctionPointerType(TCppType_t type) {
     return Cpp::IsFunctionPointerType(type);
 }
 
@@ -458,11 +458,11 @@ bool split_comma_saparated_types(const std::string& name,
   return true;
 }
 
-Cppyy::TCppScope_t GetEnumFromCompleteName(const std::string &name) {
+cppjit::interop::TCppScope_t GetEnumFromCompleteName(const std::string &name) {
   std::string delim = "::";
   size_t start = 0;
   size_t end = name.find(delim);
-  Cppyy::TCppScope_t curr_scope;
+  cppjit::interop::TCppScope_t curr_scope;
   while (end != std::string::npos) {
     curr_scope = Cpp::GetNamed(name.substr(start, end - start), curr_scope);
     start = end + delim.length();
@@ -483,8 +483,8 @@ static bool is_identifier(std::string_view s) {
 };
 
 // returns true if no new type was added.
-bool Cppyy::AppendTypesSlow(const std::string& name,
-                            std::vector<Cpp::TemplateArgInfo>& types, Cppyy::TCppScope_t parent) {
+bool cppjit::interop::AppendTypesSlow(const std::string& name,
+                            std::vector<Cpp::TemplateArgInfo>& types, cppjit::interop::TCppScope_t parent) {
 
   // Add no new type if string is empty
   if (name.empty())
@@ -527,7 +527,7 @@ bool Cppyy::AppendTypesSlow(const std::string& name,
 
   // We might have an entire expression such as int, double.
   static unsigned long long struct_count = 0;
-  std::string code = "template<typename ...T> struct __Cppyy_AppendTypesSlow {};\n";
+  std::string code = "template<typename ...T> struct __cppjit_interop_AppendTypesSlow {};\n";
   if (!struct_count)
     Cpp::Declare(code.c_str(), /*silent=*/true); // initialize the trampoline
 
@@ -536,15 +536,15 @@ bool Cppyy::AppendTypesSlow(const std::string& name,
   // won't resolve. Try the name as given, then qualified by the parent.
   std::vector<std::string> candidates = {resolved_name};
   if (parent && parent != Cpp::GetGlobalScope() &&
-      (Cppyy::IsNamespace(parent) || Cppyy::IsClass(parent)))
+      (cppjit::interop::IsNamespace(parent) || cppjit::interop::IsClass(parent)))
     candidates.push_back(Cpp::GetQualifiedCompleteName(parent) + "::" + resolved_name);
 
   for (const std::string& candidate : candidates) {
-    std::string var = "__Cppyy_s" + std::to_string(struct_count++);
+    std::string var = "__cppjit_interop_s" + std::to_string(struct_count++);
     // nodebug: with -g the variable's debug info would carry the full DIE
     // tree of every template argument (all member declarations included) --
     // a large, uncacheable per-lookup cost on heavyweight types.
-    if (!Cpp::Declare(("__Cppyy_AppendTypesSlow<" + candidate + "> __attribute__((nodebug)) " + var + ";\n").c_str(), /*silent=*/true)) {
+    if (!Cpp::Declare(("__cppjit_interop_AppendTypesSlow<" + candidate + "> __attribute__((nodebug)) " + var + ";\n").c_str(), /*silent=*/true)) {
       TCppType_t varN =
           Cpp::GetVariableType(Cpp::GetNamed(var.c_str(), /*parent=*/nullptr));
       TCppScope_t instance_class = Cpp::GetScopeFromType(varN);
@@ -564,13 +564,13 @@ bool Cppyy::AppendTypesSlow(const std::string& name,
     return true;
 
   for (std::string& i : individual_types) {
-    // Try going via Cppyy::GetType first.
+    // Try going via cppjit::interop::GetType first.
     const char* integral_value = nullptr;
-    Cppyy::TCppType_t type = nullptr;
+    cppjit::interop::TCppType_t type = nullptr;
 
     type = GetType(i, /*enable_slow_lookup=*/true);
-    if (!type && parent && (Cppyy::IsNamespace(parent) || Cppyy::IsClass(parent))) {
-        type = Cppyy::GetTypeFromScope(Cppyy::GetNamed(resolved_name, parent));
+    if (!type && parent && (cppjit::interop::IsNamespace(parent) || cppjit::interop::IsClass(parent))) {
+        type = cppjit::interop::GetTypeFromScope(cppjit::interop::GetNamed(resolved_name, parent));
     }
 
     if (!type) {
@@ -589,7 +589,7 @@ bool Cppyy::AppendTypesSlow(const std::string& name,
   return false;
 }
 
-Cppyy::TCppType_t Cppyy::GetType(const std::string &name, bool enable_slow_lookup /* = false */) {
+cppjit::interop::TCppType_t cppjit::interop::GetType(const std::string &name, bool enable_slow_lookup /* = false */) {
     // The ast printer gave us garbage.
     if (name == "<unnamed>")
       return nullptr;
@@ -617,7 +617,7 @@ Cppyy::TCppType_t Cppyy::GetType(const std::string &name, bool enable_slow_looku
 
     if (!enable_slow_lookup) {
         if (name.find("::") != std::string::npos)
-            throw std::runtime_error("Calling Cppyy::GetType with qualified name '"
+            throw std::runtime_error("Calling cppjit::interop::GetType with qualified name '"
                                 + name + "'\n");
         return nullptr;
     }
@@ -625,7 +625,7 @@ Cppyy::TCppType_t Cppyy::GetType(const std::string &name, bool enable_slow_looku
     // Here we might need to deal with integral types such as 3.14.
 
     static unsigned long long var_count = 0;
-    std::string id = "__Cppyy_GetType_" + std::to_string(var_count++);
+    std::string id = "__cppjit_interop_GetType_" + std::to_string(var_count++);
     std::string using_clause = "using " + id + " = __typeof__(" + name + ");\n";
 
     if (!Cpp::Declare(using_clause.c_str(), /*silent=*/true)) {
@@ -637,7 +637,7 @@ Cppyy::TCppType_t Cppyy::GetType(const std::string &name, bool enable_slow_looku
 }
 
 
-Cppyy::TCppType_t Cppyy::GetComplexType(const std::string &name) {
+cppjit::interop::TCppType_t cppjit::interop::GetComplexType(const std::string &name) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetComplexType(Cpp::GetType(name));
 }
@@ -647,7 +647,7 @@ Cppyy::TCppType_t Cppyy::GetComplexType(const std::string &name) {
 // static std::string extract_namespace(const std::string& name)
 // {
 // // Find the namespace the named class lives in, take care of templates
-// // Note: this code also lives in CPyCppyy (TODO: refactor?)
+// // Note: this code also lives in cpyrt (TODO: refactor?)
 //     if (name.empty())
 //         return name;
 //
@@ -673,7 +673,7 @@ Cppyy::TCppType_t Cppyy::GetComplexType(const std::string &name) {
 // }
 //
 
-std::string Cppyy::ResolveEnum(TCppScope_t handle)
+std::string cppjit::interop::ResolveEnum(TCppScope_t handle)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     std::string type = Cpp::GetTypeAsString(
@@ -683,20 +683,20 @@ std::string Cppyy::ResolveEnum(TCppScope_t handle)
     return type;
 }
 
-Cppyy::TCppScope_t Cppyy::GetUnderlyingScope(TCppScope_t scope)
+cppjit::interop::TCppScope_t cppjit::interop::GetUnderlyingScope(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetUnderlyingScope(scope);
 }
 
-Cppyy::TCppScope_t Cppyy::GetScope(const std::string& name,
+cppjit::interop::TCppScope_t cppjit::interop::GetScope(const std::string& name,
                                    TCppScope_t parent_scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
-    if (Cppyy::TCppScope_t scope = Cpp::GetScope(name, parent_scope))
+    if (cppjit::interop::TCppScope_t scope = Cpp::GetScope(name, parent_scope))
       return scope;
     if (!parent_scope || parent_scope == Cpp::GetGlobalScope())
-      if (Cppyy::TCppScope_t scope = Cpp::GetScopeFromCompleteName(name))
+      if (cppjit::interop::TCppScope_t scope = Cpp::GetScopeFromCompleteName(name))
         return scope;
 
     // FIXME: avoid string parsing here
@@ -707,7 +707,7 @@ Cppyy::TCppScope_t Cppyy::GetScope(const std::string& name,
       // represent non-type arguments such as the `3` in std::array<float, 3>.
       std::vector<Cpp::TemplateArgInfo> types;
       InterOpMutex.unlock(); // unlock to allow AppendTypesSlow
-      bool added_new_type = !Cppyy::AppendTypesSlow(name, types, /*parent=*/parent_scope);
+      bool added_new_type = !cppjit::interop::AppendTypesSlow(name, types, /*parent=*/parent_scope);
       std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
       if (added_new_type && types.size() == 1) {
         // A pointer or reference spelling (e.g. "std::chrono::nanoseconds *",
@@ -730,60 +730,60 @@ Cppyy::TCppScope_t Cppyy::GetScope(const std::string& name,
     return nullptr;
 }
 
-Cppyy::TCppScope_t Cppyy::GetFullScope(const std::string& name)
+cppjit::interop::TCppScope_t cppjit::interop::GetFullScope(const std::string& name)
 {
-  return Cppyy::GetScope(name);
+  return cppjit::interop::GetScope(name);
 }
 
-Cppyy::TCppScope_t Cppyy::GetTypeScope(TCppScope_t var)
+cppjit::interop::TCppScope_t cppjit::interop::GetTypeScope(TCppScope_t var)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetScopeFromType(
         Cpp::GetVariableType(var));
 }
 
-Cppyy::TCppScope_t Cppyy::GetNamed(const std::string& name,
+cppjit::interop::TCppScope_t cppjit::interop::GetNamed(const std::string& name,
                                    TCppScope_t parent_scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetNamed(name, parent_scope);
 }
 
-Cppyy::TCppScope_t Cppyy::GetParentScope(TCppScope_t scope)
+cppjit::interop::TCppScope_t cppjit::interop::GetParentScope(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetParentScope(scope);
 }
 
-Cppyy::TCppScope_t Cppyy::GetScopeFromType(TCppType_t type)
+cppjit::interop::TCppScope_t cppjit::interop::GetScopeFromType(TCppType_t type)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetScopeFromType(type);
 }
 
-Cppyy::TCppType_t Cppyy::GetTypeFromScope(TCppScope_t klass)
+cppjit::interop::TCppType_t cppjit::interop::GetTypeFromScope(TCppScope_t klass)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetTypeFromScope(klass);
 }
 
-Cppyy::TCppScope_t Cppyy::GetGlobalScope()
+cppjit::interop::TCppScope_t cppjit::interop::GetGlobalScope()
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetGlobalScope();
 }
 
-bool Cppyy::IsTemplate(TCppScope_t handle)
+bool cppjit::interop::IsTemplate(TCppScope_t handle)
 {
     return Cpp::IsTemplate(handle);
 }
 
-bool Cppyy::IsTemplateInstantiation(TCppScope_t handle)
+bool cppjit::interop::IsTemplateInstantiation(TCppScope_t handle)
 {
     return Cpp::IsTemplateSpecialization(handle);
 }
 
-bool Cppyy::IsTypedefed(TCppScope_t handle)
+bool cppjit::interop::IsTypedefed(TCppScope_t handle)
 {
     return Cpp::IsTypedefed(handle);
 }
@@ -795,7 +795,7 @@ class AutoCastRTTI {
 };
 } // namespace
 
-Cppyy::TCppScope_t Cppyy::GetActualClass(TCppScope_t klass, TCppObject_t obj) {
+cppjit::interop::TCppScope_t cppjit::interop::GetActualClass(TCppScope_t klass, TCppObject_t obj) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
 
     if (!Cpp::IsClassPolymorphic(klass))
@@ -806,25 +806,25 @@ Cppyy::TCppScope_t Cppyy::GetActualClass(TCppScope_t klass, TCppObject_t obj) {
     std::string mangled_name = typ->name();
     std::string demangled_name = Cpp::Demangle(mangled_name);
 
-    if (TCppScope_t scope = Cppyy::GetScope(demangled_name))
+    if (TCppScope_t scope = cppjit::interop::GetScope(demangled_name))
         return scope;
 
     return klass;
 }
 
-size_t Cppyy::SizeOf(TCppScope_t klass)
+size_t cppjit::interop::SizeOf(TCppScope_t klass)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::SizeOf(klass);
 }
 
-size_t Cppyy::SizeOfType(TCppType_t klass)
+size_t cppjit::interop::SizeOfType(TCppType_t klass)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetSizeOfType(klass);
 }
 
-bool Cppyy::IsBuiltin(const std::string& type_name)
+bool cppjit::interop::IsBuiltin(const std::string& type_name)
 {
     static std::set<std::string> s_builtins =
        {"bool", "char", "signed char", "unsigned char", "wchar_t", "short",
@@ -840,38 +840,38 @@ bool Cppyy::IsBuiltin(const std::string& type_name)
     return false;
 }
 
-bool Cppyy::IsBuiltin(TCppType_t type)
+bool cppjit::interop::IsBuiltin(TCppType_t type)
 {
     return  Cpp::IsBuiltin(type);
     
 }
 
-bool Cppyy::IsComplete(TCppScope_t scope)
+bool cppjit::interop::IsComplete(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::IsComplete(scope);
 }
 
 // // memory management ---------------------------------------------------------
-Cppyy::TCppObject_t Cppyy::Allocate(TCppScope_t scope)
+cppjit::interop::TCppObject_t cppjit::interop::Allocate(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::Allocate(scope, /*count=*/1);
 }
 
-void Cppyy::Deallocate(TCppScope_t scope, TCppObject_t instance)
+void cppjit::interop::Deallocate(TCppScope_t scope, TCppObject_t instance)
 {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   Cpp::Deallocate(scope, instance, /*count=*/1);
 }
 
-Cppyy::TCppObject_t Cppyy::Construct(TCppScope_t scope, void* arena/*=nullptr*/)
+cppjit::interop::TCppObject_t cppjit::interop::Construct(TCppScope_t scope, void* arena/*=nullptr*/)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex); // TODO: this shouldn't locks the JIT call
     return Cpp::Construct(scope, arena, /*count=*/1);
 }
 
-void Cppyy::Destruct(TCppScope_t scope, TCppObject_t instance)
+void cppjit::interop::Destruct(TCppScope_t scope, TCppObject_t instance)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);  // TODO: this shouldn't locks the JIT call
     Cpp::Destruct(instance, scope, true, /*count=*/0);
@@ -908,7 +908,7 @@ void release_args(Parameter* args, size_t nargs) {
 }
 
 static inline
-bool WrapperCall(Cppyy::TCppMethod_t method, size_t nargs, void* args_, void* self, void* result)
+bool WrapperCall(cppjit::interop::TCppMethod_t method, size_t nargs, void* args_, void* self, void* result)
 {
     Parameter* args = (Parameter*)args_;
     //bool is_direct = nargs & DIRECT_CALL;
@@ -943,7 +943,7 @@ bool WrapperCall(Cppyy::TCppMethod_t method, size_t nargs, void* args_, void* se
 
 template<typename T>
 static inline
-T CallT(Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, size_t nargs, void* args)
+T CallT(cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, size_t nargs, void* args)
 {
     T t{};
     if (WrapperCall(method, nargs, args, self.data, &t))
@@ -959,30 +959,30 @@ T CallT(Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, size_t nargs, void
     #define _IMP_CALL_PRINT_STMT(type)
 #endif
 
-#define CPPYY_IMP_CALL(typecode, rtype)                                      \
-rtype Cppyy::Call##typecode(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args)\
+#define CPPJIT_IMP_CALL(typecode, rtype)                                      \
+rtype cppjit::interop::Call##typecode(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args)\
 {                                                                            \
     _IMP_CALL_PRINT_STMT(rtype)                                              \
     return CallT<rtype>(method, self, nargs, args);                          \
 }
 
-void Cppyy::CallV(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args)
+void cppjit::interop::CallV(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args)
 {
     if (!WrapperCall(method, nargs, args, self.data, nullptr))
         return /* TODO ... report error */;
 }
 
-CPPYY_IMP_CALL(B,  unsigned char)
-CPPYY_IMP_CALL(C,  char         )
-CPPYY_IMP_CALL(H,  short        )
-CPPYY_IMP_CALL(I,  int          )
-CPPYY_IMP_CALL(L,  long         )
-CPPYY_IMP_CALL(LL, long long    )
-CPPYY_IMP_CALL(F,  float        )
-CPPYY_IMP_CALL(D,  double       )
-CPPYY_IMP_CALL(LD, long double  )
+CPPJIT_IMP_CALL(B,  unsigned char)
+CPPJIT_IMP_CALL(C,  char         )
+CPPJIT_IMP_CALL(H,  short        )
+CPPJIT_IMP_CALL(I,  int          )
+CPPJIT_IMP_CALL(L,  long         )
+CPPJIT_IMP_CALL(LL, long long    )
+CPPJIT_IMP_CALL(F,  float        )
+CPPJIT_IMP_CALL(D,  double       )
+CPPJIT_IMP_CALL(LD, long double  )
 
-void* Cppyy::CallR(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args)
+void* cppjit::interop::CallR(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args)
 {
     void* r = nullptr;
     if (WrapperCall(method, nargs, args, self.data, &r))
@@ -990,7 +990,7 @@ void* Cppyy::CallR(TCppMethod_t method, TCppObject_t self, size_t nargs, void* a
     return nullptr;
 }
 
-char* Cppyy::CallS(
+char* cppjit::interop::CallS(
     TCppMethod_t method, TCppObject_t self, size_t nargs, void* args, size_t* length)
 {
     char* cstr = nullptr;
@@ -1006,7 +1006,7 @@ char* Cppyy::CallS(
     return cstr;
 }
 
-Cppyy::TCppObject_t Cppyy::CallConstructor(
+cppjit::interop::TCppObject_t cppjit::interop::CallConstructor(
     TCppMethod_t method, TCppScope_t /*klass*/, size_t nargs, void* args)
 {
     void* obj = nullptr;
@@ -1014,23 +1014,23 @@ Cppyy::TCppObject_t Cppyy::CallConstructor(
     return (TCppObject_t)obj;
 }
 
-void Cppyy::CallDestructor(TCppScope_t scope, TCppObject_t self)
+void cppjit::interop::CallDestructor(TCppScope_t scope, TCppObject_t self)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex); // TODO: this shouldn't locks the JIT call
     Cpp::Destruct(self, scope, /*withFree=*/false, /*count=*/0);
 }
 
-Cppyy::TCppObject_t Cppyy::CallO(TCppMethod_t method,
+cppjit::interop::TCppObject_t cppjit::interop::CallO(TCppMethod_t method,
     TCppObject_t self, size_t nargs, void* args, TCppType_t result_type)
 {
-    void* obj = ::operator new(Cppyy::SizeOfType(result_type));
+    void* obj = ::operator new(cppjit::interop::SizeOfType(result_type));
     if (WrapperCall(method, nargs, args, self.data, obj))
         return (TCppObject_t)obj;
     ::operator delete(obj);
     return TCppObject_t{};
 }
 
-Cppyy::TCppFuncAddr_t Cppyy::GetFunctionAddress(TCppMethod_t method, bool /*check_enabled*/)
+cppjit::interop::TCppFuncAddr_t cppjit::interop::GetFunctionAddress(TCppMethod_t method, bool /*check_enabled*/)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetFunctionAddress(method);
@@ -1038,29 +1038,29 @@ Cppyy::TCppFuncAddr_t Cppyy::GetFunctionAddress(TCppMethod_t method, bool /*chec
 
 
 // handling of function argument buffer --------------------------------------
-void* Cppyy::AllocateFunctionArgs(size_t nargs)
+void* cppjit::interop::AllocateFunctionArgs(size_t nargs)
 {
     return new Parameter[nargs];
 }
 
-void Cppyy::DeallocateFunctionArgs(void* args)
+void cppjit::interop::DeallocateFunctionArgs(void* args)
 {
     delete [] (Parameter*)args;
 }
 
-size_t Cppyy::GetFunctionArgSizeof()
+size_t cppjit::interop::GetFunctionArgSizeof()
 {
     return sizeof(Parameter);
 }
 
-size_t Cppyy::GetFunctionArgTypeoffset()
+size_t cppjit::interop::GetFunctionArgTypeoffset()
 {
     return offsetof(Parameter, fTypeCode);
 }
 
 
 // scope reflection information ----------------------------------------------
-bool Cppyy::IsNamespace(TCppScope_t scope)
+bool cppjit::interop::IsNamespace(TCppScope_t scope)
 {
     if (!scope)
       return false;
@@ -1070,47 +1070,47 @@ bool Cppyy::IsNamespace(TCppScope_t scope)
     return Cpp::IsNamespace(scope) || Cpp::GetGlobalScope() == scope;
 }
 
-bool Cppyy::IsClass(TCppScope_t scope)
+bool cppjit::interop::IsClass(TCppScope_t scope)
 {
     // Test if this scope represents a namespace.
     return Cpp::IsClass(scope);
 }
 //
-bool Cppyy::IsAbstract(TCppScope_t scope)
+bool cppjit::interop::IsAbstract(TCppScope_t scope)
 {
     // Test if this type may not be instantiated.
     return Cpp::IsAbstract(scope);
 }
 
-bool Cppyy::IsEnumScope(TCppScope_t scope)
+bool cppjit::interop::IsEnumScope(TCppScope_t scope)
 {
     return Cpp::IsEnumScope(scope);
 }
 
-bool Cppyy::IsEnumConstant(TCppScope_t scope)
+bool cppjit::interop::IsEnumConstant(TCppScope_t scope)
 {
-  return Cpp::IsEnumConstant(Cppyy::GetUnderlyingScope(scope));
+  return Cpp::IsEnumConstant(cppjit::interop::GetUnderlyingScope(scope));
 }
 
-bool Cppyy::IsEnumType(TCppType_t type)
+bool cppjit::interop::IsEnumType(TCppType_t type)
 {
     return Cpp::IsEnumType(type);
 }
 
-bool Cppyy::IsAggregate(TCppScope_t type)
+bool cppjit::interop::IsAggregate(TCppScope_t type)
 {
   // Test if this type is a "plain old data" type
   return Cpp::IsAggregate(type);
 }
 
-bool Cppyy::IsDefaultConstructable(TCppScope_t scope)
+bool cppjit::interop::IsDefaultConstructable(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
 // Test if this type has a default constructor or is a "plain old data" type
     return Cpp::HasDefaultConstructor(scope);
 }
 
-bool Cppyy::IsVariable(TCppScope_t scope)
+bool cppjit::interop::IsVariable(TCppScope_t scope)
 {
     return Cpp::IsVariable(scope);
 }
@@ -1166,7 +1166,7 @@ bool Cppyy::IsVariable(TCppScope_t scope)
 //     }}}
 //
 // static inline
-// void cond_add(Cppyy::TCppScope_t scope, const std::string& ns_scope,
+// void cond_add(cppjit::interop::TCppScope_t scope, const std::string& ns_scope,
 //     std::set<std::string>& cppnames, const char* name, bool nofilter = false)
 // {
 //     if (!name || name[0] == '_' || strstr(name, ".h") != 0 || strncmp(name, "operator", 8) == 0)
@@ -1190,7 +1190,7 @@ bool Cppyy::IsVariable(TCppScope_t scope)
 //     }
 // }
 
-void Cppyy::GetAllCppNames(TCppScope_t scope, std::set<std::string>& cppnames)
+void cppjit::interop::GetAllCppNames(TCppScope_t scope, std::set<std::string>& cppnames)
 {
 // Collect all known names of C++ entities under scope. This is useful for IDEs
 // employing tab-completion, for example. Note that functions names need not be
@@ -1200,33 +1200,33 @@ void Cppyy::GetAllCppNames(TCppScope_t scope, std::set<std::string>& cppnames)
 }
 
 // class reflection information ----------------------------------------------
-std::vector<Cppyy::TCppScope_t> Cppyy::GetUsingNamespaces(TCppScope_t scope)
+std::vector<cppjit::interop::TCppScope_t> cppjit::interop::GetUsingNamespaces(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetUsingNamespaces(scope);
 }
 
 // class reflection information ----------------------------------------------
-std::string Cppyy::GetFinalName(TCppScope_t klass)
+std::string cppjit::interop::GetFinalName(TCppScope_t klass)
 {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   return Cpp::GetCompleteName(Cpp::GetUnderlyingScope(klass));
 }
 
-std::string Cppyy::GetScopedFinalName(TCppScope_t klass)
+std::string cppjit::interop::GetScopedFinalName(TCppScope_t klass)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetQualifiedCompleteName(klass);
 }
 
-bool Cppyy::HasVirtualDestructor(TCppScope_t scope)
+bool cppjit::interop::HasVirtualDestructor(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     TCppMethod_t func = Cpp::GetDestructor(scope);
     return Cpp::IsVirtualMethod(func);
 }
 
-Cppyy::TCppIndex_t Cppyy::GetNumBases(TCppScope_t klass)
+cppjit::interop::TCppIndex_t cppjit::interop::GetNumBases(TCppScope_t klass)
 {
 // Get the total number of base classes that this class has.
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
@@ -1234,12 +1234,12 @@ Cppyy::TCppIndex_t Cppyy::GetNumBases(TCppScope_t klass)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-/// \fn Cppyy::TCppIndex_t Cppyy::GetNumBasesLongestBranch(TCppScope_t klass)
+/// \fn cppjit::interop::TCppIndex_t cppjit::interop::GetNumBasesLongestBranch(TCppScope_t klass)
 /// \brief Retrieve number of base classes in the longest branch of the
 ///        inheritance tree of the input class.
 /// \param[in] klass The class to start the retrieval process from.
 ///
-/// This is a helper function for Cppyy::GetNumBasesLongestBranch.
+/// This is a helper function for cppjit::interop::GetNumBasesLongestBranch.
 /// Given an inheritance tree, the function assigns weight 1 to each class that
 /// has at least one base. Starting from the input class, the function is
 /// called recursively on all the bases. For each base the return value is one
@@ -1254,28 +1254,28 @@ Cppyy::TCppIndex_t Cppyy::GetNumBases(TCppScope_t klass)
 ///
 /// calling this function on an instance of `C` will return 3, the steps
 /// required to go from C to X.
-Cppyy::TCppIndex_t Cppyy::GetNumBasesLongestBranch(TCppScope_t klass) {
+cppjit::interop::TCppIndex_t cppjit::interop::GetNumBasesLongestBranch(TCppScope_t klass) {
     std::vector<size_t> num;
     for (TCppIndex_t ibase = 0; ibase < GetNumBases(klass); ++ibase)
-        num.push_back(GetNumBasesLongestBranch(Cppyy::GetBaseScope(klass, ibase)));
+        num.push_back(GetNumBasesLongestBranch(cppjit::interop::GetBaseScope(klass, ibase)));
     if (num.empty())
         return 0;
     return *std::max_element(num.begin(), num.end()) + 1;
 }
 
-std::string Cppyy::GetBaseName(TCppScope_t klass, TCppIndex_t ibase)
+std::string cppjit::interop::GetBaseName(TCppScope_t klass, TCppIndex_t ibase)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetName(Cpp::GetBaseClass(klass, ibase));
 }
 
-Cppyy::TCppScope_t Cppyy::GetBaseScope(TCppScope_t klass, TCppIndex_t ibase)
+cppjit::interop::TCppScope_t cppjit::interop::GetBaseScope(TCppScope_t klass, TCppIndex_t ibase)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetBaseClass(klass, ibase);
 }
 
-bool Cppyy::IsSubclass(TCppScope_t derived, TCppScope_t base)
+bool cppjit::interop::IsSubclass(TCppScope_t derived, TCppScope_t base)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::IsSubclass(derived, base);
@@ -1284,15 +1284,15 @@ bool Cppyy::IsSubclass(TCppScope_t derived, TCppScope_t base)
 static std::set<std::string> gSmartPtrTypes =
     {"std::auto_ptr", "std::shared_ptr", "std::unique_ptr", "std::weak_ptr"};
 
-bool Cppyy::IsSmartPtr(TCppScope_t klass)
+bool cppjit::interop::IsSmartPtr(TCppScope_t klass)
 {
-    const std::string& rn = Cppyy::GetScopedFinalName(klass);
+    const std::string& rn = cppjit::interop::GetScopedFinalName(klass);
     if (gSmartPtrTypes.find(rn.substr(0, rn.find("<"))) != gSmartPtrTypes.end())
         return true;
     return false;
 }
 
-bool Cppyy::GetSmartPtrInfo(
+bool cppjit::interop::GetSmartPtrInfo(
     const std::string& tname, TCppScope_t* raw, TCppMethod_t* deref)
 {
     // TODO: We can directly accept scope instead of name
@@ -1302,7 +1302,7 @@ bool Cppyy::GetSmartPtrInfo(
 
     if (!raw && !deref) return true;
 
-    TCppScope_t scope = Cppyy::GetScope(rn);
+    TCppScope_t scope = cppjit::interop::GetScope(rn);
     if (!scope)
         return false;
 
@@ -1316,12 +1316,12 @@ bool Cppyy::GetSmartPtrInfo(
         return false;
 
     if (deref) *deref = ops[0];
-    if (raw) *raw = Cppyy::GetScopeFromType(Cppyy::GetMethodReturnType(ops[0]));
+    if (raw) *raw = cppjit::interop::GetScopeFromType(cppjit::interop::GetMethodReturnType(ops[0]));
     return (!deref || *deref) && (!raw || *raw);
 }
 
 // type offsets --------------------------------------------------------------
-ptrdiff_t Cppyy::GetBaseOffset(TCppScope_t derived, TCppScope_t base,
+ptrdiff_t cppjit::interop::GetBaseOffset(TCppScope_t derived, TCppScope_t base,
     TCppObject_t /*address*/, int direction, bool rerror)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
@@ -1334,38 +1334,38 @@ ptrdiff_t Cppyy::GetBaseOffset(TCppScope_t derived, TCppScope_t base,
 }
 
 // method/function reflection information ------------------------------------
-void Cppyy::GetClassMethods(TCppScope_t scope, std::vector<Cppyy::TCppMethod_t> &methods)
+void cppjit::interop::GetClassMethods(TCppScope_t scope, std::vector<cppjit::interop::TCppMethod_t> &methods)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     Cpp::GetClassMethods(scope, methods);
 }
 
-std::vector<Cppyy::TCppMethod_t> Cppyy::GetMethodsFromName(
+std::vector<cppjit::interop::TCppMethod_t> cppjit::interop::GetMethodsFromName(
     TCppScope_t scope, const std::string& name)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetFunctionsUsingName(scope, name);
 }
 
-std::string Cppyy::GetName(TCppScope_t method)
+std::string cppjit::interop::GetName(TCppScope_t method)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetName(method);
 }
 
-std::string Cppyy::GetFullName(TCppScope_t method)
+std::string cppjit::interop::GetFullName(TCppScope_t method)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetCompleteName(method);
 }
 
-Cppyy::TCppType_t Cppyy::GetMethodReturnType(TCppMethod_t method)
+cppjit::interop::TCppType_t cppjit::interop::GetMethodReturnType(TCppMethod_t method)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetFunctionReturnType(method);
 }
 
-std::string Cppyy::GetMethodReturnTypeAsString(TCppMethod_t method)
+std::string cppjit::interop::GetMethodReturnTypeAsString(TCppMethod_t method)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return 
@@ -1374,19 +1374,19 @@ std::string Cppyy::GetMethodReturnTypeAsString(TCppMethod_t method)
             Cpp::GetFunctionReturnType(method)));
 }
 
-Cppyy::TCppIndex_t Cppyy::GetMethodNumArgs(TCppMethod_t method)
+cppjit::interop::TCppIndex_t cppjit::interop::GetMethodNumArgs(TCppMethod_t method)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetFunctionNumArgs(method);
 }
 
-Cppyy::TCppIndex_t Cppyy::GetMethodReqArgs(TCppMethod_t method)
+cppjit::interop::TCppIndex_t cppjit::interop::GetMethodReqArgs(TCppMethod_t method)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetFunctionRequiredArgs(method);
 }
 
-std::string Cppyy::GetMethodArgName(TCppMethod_t method, TCppIndex_t iarg)
+std::string cppjit::interop::GetMethodArgName(TCppMethod_t method, TCppIndex_t iarg)
 {
     if (!method)
         return "<unknown>";
@@ -1395,20 +1395,20 @@ std::string Cppyy::GetMethodArgName(TCppMethod_t method, TCppIndex_t iarg)
     return Cpp::GetFunctionArgName(method, iarg);
 }
 
-Cppyy::TCppType_t Cppyy::GetMethodArgType(TCppMethod_t method, TCppIndex_t iarg)
+cppjit::interop::TCppType_t cppjit::interop::GetMethodArgType(TCppMethod_t method, TCppIndex_t iarg)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetFunctionArgType(method, iarg);
 }
 
-std::string Cppyy::GetMethodArgTypeAsString(TCppMethod_t method, TCppIndex_t iarg)
+std::string cppjit::interop::GetMethodArgTypeAsString(TCppMethod_t method, TCppIndex_t iarg)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetTypeAsString(Cpp::RemoveTypeQualifier(
       Cpp::GetFunctionArgType(method, iarg), Cpp::QualKind::Const));
 }
 
-std::string Cppyy::GetMethodArgCanonTypeAsString(TCppMethod_t method, TCppIndex_t iarg)
+std::string cppjit::interop::GetMethodArgCanonTypeAsString(TCppMethod_t method, TCppIndex_t iarg)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return
@@ -1417,7 +1417,7 @@ std::string Cppyy::GetMethodArgCanonTypeAsString(TCppMethod_t method, TCppIndex_
             Cpp::GetFunctionArgType(method, iarg)));
 }
 
-std::string Cppyy::GetMethodArgDefault(TCppMethod_t method, TCppIndex_t iarg)
+std::string cppjit::interop::GetMethodArgDefault(TCppMethod_t method, TCppIndex_t iarg)
 {
     if (!method)
        return "";
@@ -1426,7 +1426,7 @@ std::string Cppyy::GetMethodArgDefault(TCppMethod_t method, TCppIndex_t iarg)
     return Cpp::GetFunctionArgDefault(method, iarg);
 }
 
-Cppyy::TCppIndex_t Cppyy::CompareMethodArgType(TCppMethod_t /*method*/, TCppIndex_t iarg, const std::string &req_type)
+cppjit::interop::TCppIndex_t cppjit::interop::CompareMethodArgType(TCppMethod_t /*method*/, TCppIndex_t iarg, const std::string &req_type)
 {
     // if (method) {
     //     TFunction* f = m2f(method);
@@ -1455,18 +1455,18 @@ Cppyy::TCppIndex_t Cppyy::CompareMethodArgType(TCppMethod_t /*method*/, TCppInde
     return 0; // Method is not valid
 }
 
-std::string Cppyy::GetMethodSignature(TCppMethod_t method, bool show_formal_args, TCppIndex_t max_args)
+std::string cppjit::interop::GetMethodSignature(TCppMethod_t method, bool show_formal_args, TCppIndex_t max_args)
 {
     std::ostringstream sig;
     sig << "(";
     int nArgs = GetMethodNumArgs(method);
     if (max_args != (TCppIndex_t)-1) nArgs = std::min(nArgs, (int)max_args);
     for (int iarg = 0; iarg < nArgs; ++iarg) {
-        sig << Cppyy::GetMethodArgTypeAsString(method, iarg);
+        sig << cppjit::interop::GetMethodArgTypeAsString(method, iarg);
         if (show_formal_args) {
-            std::string argname = Cppyy::GetMethodArgName(method, iarg);
+            std::string argname = cppjit::interop::GetMethodArgName(method, iarg);
             if (!argname.empty()) sig << " " << argname;
-            std::string defvalue = Cppyy::GetMethodArgDefault(method, iarg);
+            std::string defvalue = cppjit::interop::GetMethodArgDefault(method, iarg);
             if (!defvalue.empty()) sig << " = " << defvalue;
         }
         if (iarg != nArgs-1) sig << ", ";
@@ -1475,7 +1475,7 @@ std::string Cppyy::GetMethodSignature(TCppMethod_t method, bool show_formal_args
     return sig.str();
 }
 
-Cppyy::TCppType_t Cppyy::GetFnTypeFromStdFn(TCppType_t fn_type) {
+cppjit::interop::TCppType_t cppjit::interop::GetFnTypeFromStdFn(TCppType_t fn_type) {
     fn_type = Cpp::IsReferenceType(fn_type) ? Cpp::GetNonReferenceType(fn_type) : fn_type;
     fn_type = Cpp::IsPointerType(fn_type) ? Cpp::GetPointeeType(fn_type) : fn_type;
     TCppScope_t scope = Cpp::GetScopeFromType(fn_type);
@@ -1487,23 +1487,23 @@ Cppyy::TCppType_t Cppyy::GetFnTypeFromStdFn(TCppType_t fn_type) {
     return nullptr;
 }
 
-void Cppyy::GetFnTypeSig(TCppType_t fn_type, std::vector<TCppType_t>& arg_types) {
+void cppjit::interop::GetFnTypeSig(TCppType_t fn_type, std::vector<TCppType_t>& arg_types) {
     fn_type = Cpp::IsReferenceType(fn_type) ? Cpp::GetNonReferenceType(fn_type) : fn_type;
     fn_type = Cpp::IsPointerType(fn_type) ? Cpp::GetPointeeType(fn_type) : fn_type;
     Cpp::GetFnTypeSignature(fn_type, arg_types);
 }
 
-bool Cppyy::IsSameType(TCppType_t typ1, TCppType_t typ2) {
+bool cppjit::interop::IsSameType(TCppType_t typ1, TCppType_t typ2) {
     return Cpp::IsSameType(typ1, typ2);
 }
 
-bool Cppyy::IsFunctionType(TCppType_t typ) {
+bool cppjit::interop::IsFunctionType(TCppType_t typ) {
     typ = Cpp::IsReferenceType(typ) ? Cpp::GetNonReferenceType(typ) : typ;
     typ = Cpp::IsPointerType(typ) ? Cpp::GetPointeeType(typ) : typ;
     return Cpp::IsFunctionProtoType(typ);
 }
 
-bool Cppyy::IsSimilarFnTypes(TCppType_t typ1, TCppType_t typ2) {
+bool cppjit::interop::IsSimilarFnTypes(TCppType_t typ1, TCppType_t typ2) {
     typ1 = Cpp::IsReferenceType(typ1) ? Cpp::GetNonReferenceType(typ1) : typ1;
     typ2 = Cpp::IsReferenceType(typ2) ? Cpp::GetNonReferenceType(typ2) : typ2;
     typ1 = Cpp::IsPointerType(typ1) ? Cpp::GetPointeeType(typ1) : typ1;
@@ -1511,13 +1511,13 @@ bool Cppyy::IsSimilarFnTypes(TCppType_t typ1, TCppType_t typ2) {
     return Cpp::IsSameType(typ1, typ2);
 }
 
-std::string Cppyy::GetDoxygenComment(TCppScope_t scope, bool strip_markers)
+std::string cppjit::interop::GetDoxygenComment(TCppScope_t scope, bool strip_markers)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetDoxygenComment(scope, strip_markers);
 }
 
-bool Cppyy::IsConstMethod(TCppMethod_t method)
+bool cppjit::interop::IsConstMethod(TCppMethod_t method)
 {
     if (!method)
         return false;
@@ -1525,24 +1525,24 @@ bool Cppyy::IsConstMethod(TCppMethod_t method)
     return Cpp::IsConstMethod(method);
 }
 
-void Cppyy::GetTemplatedMethods(TCppScope_t scope, std::vector<Cppyy::TCppMethod_t> &methods)
+void cppjit::interop::GetTemplatedMethods(TCppScope_t scope, std::vector<cppjit::interop::TCppMethod_t> &methods)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     Cpp::GetFunctionTemplatedDecls(scope, methods);
 }
 
-Cppyy::TCppIndex_t Cppyy::GetNumTemplatedMethods(TCppScope_t scope, bool /*accept_namespace*/)
+cppjit::interop::TCppIndex_t cppjit::interop::GetNumTemplatedMethods(TCppScope_t scope, bool /*accept_namespace*/)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
-    std::vector<Cppyy::TCppMethod_t> mc;
+    std::vector<cppjit::interop::TCppMethod_t> mc;
     Cpp::GetFunctionTemplatedDecls(scope, mc);
     return mc.size();
 }
 
-std::string Cppyy::GetTemplatedMethodName(TCppScope_t scope, TCppIndex_t imeth)
+std::string cppjit::interop::GetTemplatedMethodName(TCppScope_t scope, TCppIndex_t imeth)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
-    std::vector<Cppyy::TCppMethod_t> mc;
+    std::vector<cppjit::interop::TCppMethod_t> mc;
     Cpp::GetFunctionTemplatedDecls(scope, mc);
 
     if (imeth < mc.size()) return Cpp::GetName(TCppScope_t(mc[imeth].data));
@@ -1550,18 +1550,18 @@ std::string Cppyy::GetTemplatedMethodName(TCppScope_t scope, TCppIndex_t imeth)
     return "";
 }
 
-bool Cppyy::ExistsMethodTemplate(TCppScope_t scope, const std::string& name)
+bool cppjit::interop::ExistsMethodTemplate(TCppScope_t scope, const std::string& name)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::ExistsFunctionTemplate(name, scope);
 }
 
-bool Cppyy::IsTemplatedMethod(TCppMethod_t method)
+bool cppjit::interop::IsTemplatedMethod(TCppMethod_t method)
 {
     return Cpp::IsTemplatedFunction(method);
 }
 
-bool Cppyy::IsStaticTemplate(TCppScope_t scope, const std::string& name)
+bool cppjit::interop::IsStaticTemplate(TCppScope_t scope, const std::string& name)
 {
     std::vector<TCppMethod_t> candidate_methods;
     Cpp::GetClassTemplatedMethods(name, scope, candidate_methods);
@@ -1575,7 +1575,7 @@ bool Cppyy::IsStaticTemplate(TCppScope_t scope, const std::string& name)
     return is_static;
 }
 
-Cppyy::TCppMethod_t Cppyy::GetMethodTemplate(
+cppjit::interop::TCppMethod_t cppjit::interop::GetMethodTemplate(
     TCppScope_t scope, const std::string& name, const std::string& proto)
 {
     std::string pureName;
@@ -1593,19 +1593,19 @@ Cppyy::TCppMethod_t Cppyy::GetMethodTemplate(
     
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
 
-    std::vector<Cppyy::TCppMethod_t> unresolved_candidate_methods;
+    std::vector<cppjit::interop::TCppMethod_t> unresolved_candidate_methods;
     Cpp::GetClassTemplatedMethods(pureName, scope, unresolved_candidate_methods);
     if (unresolved_candidate_methods.empty() && name.find("operator") == 0) {
         // try operators
-        Cppyy::GetClassOperators(scope, pureName, unresolved_candidate_methods);
+        cppjit::interop::GetClassOperators(scope, pureName, unresolved_candidate_methods);
     }
 
-    // CPyCppyy assumes that we attempt instantiation here
+    // cpyrt assumes that we attempt instantiation here
     std::vector<Cpp::TemplateArgInfo> arg_types;
     std::vector<Cpp::TemplateArgInfo> templ_params;
-    Cppyy::AppendTypesSlow(proto, arg_types, scope);
-    Cppyy::AppendTypesSlow(explicit_params, templ_params, scope);
-    Cppyy::TCppMethod_t cppmeth = nullptr;
+    cppjit::interop::AppendTypesSlow(proto, arg_types, scope);
+    cppjit::interop::AppendTypesSlow(explicit_params, templ_params, scope);
+    cppjit::interop::TCppMethod_t cppmeth = nullptr;
     cppmeth = Cpp::BestOverloadFunctionMatch(
         unresolved_candidate_methods, templ_params, arg_types);
 
@@ -1638,7 +1638,7 @@ static inline std::string type_remap(const std::string& n1,
     // combos of string/str, wstring/str, string/unicode and wstring/unicode;
     // since C++ does not have a operator+(std::string, std::wstring), we'll
     // have to look up the same type and rely on the converters in
-    // CPyCppyy/_cppyy.
+    // cpyrt/_cppjit.
     if (n1 == "str" || n1 == "unicode" || n1 == "std::basic_string<char>") {
         if (n2 == "std::basic_string<wchar_t>")
             return "std::basic_string<wchar_t>&";                      // match like for like
@@ -1651,7 +1651,7 @@ static inline std::string type_remap(const std::string& n1,
     return n1;
 }
 
-void Cppyy::GetClassOperators(Cppyy::TCppScope_t klass,
+void cppjit::interop::GetClassOperators(cppjit::interop::TCppScope_t klass,
                               const std::string& opname,
                               std::vector<TCppMethod_t>& operators) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
@@ -1660,7 +1660,7 @@ void Cppyy::GetClassOperators(Cppyy::TCppScope_t klass,
                      /*kind=*/Cpp::OperatorArity::kBoth);
 }
 
-Cppyy::TCppMethod_t Cppyy::GetGlobalOperator(
+cppjit::interop::TCppMethod_t cppjit::interop::GetGlobalOperator(
     TCppScope_t scope, const std::string& lc, const std::string& rc, const std::string& opname)
 {
     std::string rc_type = type_remap(rc, lc);
@@ -1672,11 +1672,11 @@ Cppyy::TCppMethod_t Cppyy::GetGlobalOperator(
 
     // Avoid pushing nullptr into arg_types which would crash
     // BestOverloadFunctionMatch when it dereferences each entry's QualType.
-    auto resolve_arg_type = [](const std::string& name) -> Cppyy::TCppType_t {
-        if (auto s = Cppyy::GetScope(name))
-            if (auto t = Cppyy::GetTypeFromScope(s))
-                return Cppyy::GetReferencedType(t);
-        return Cppyy::GetType(name, /*enable_slow_lookup=*/true);
+    auto resolve_arg_type = [](const std::string& name) -> cppjit::interop::TCppType_t {
+        if (auto s = cppjit::interop::GetScope(name))
+            if (auto t = cppjit::interop::GetTypeFromScope(s))
+                return cppjit::interop::GetReferencedType(t);
+        return cppjit::interop::GetType(name, /*enable_slow_lookup=*/true);
     };
     
     std::vector<Cpp::TemplateArgInfo> arg_types;
@@ -1691,7 +1691,7 @@ Cppyy::TCppMethod_t Cppyy::GetGlobalOperator(
         else
             return nullptr;
     }
-    Cppyy::TCppMethod_t cppmeth = Cpp::BestOverloadFunctionMatch(
+    cppjit::interop::TCppMethod_t cppmeth = Cpp::BestOverloadFunctionMatch(
         overloads, {}, arg_types);
     if (cppmeth)
         return cppmeth;
@@ -1699,48 +1699,48 @@ Cppyy::TCppMethod_t Cppyy::GetGlobalOperator(
 }
 
 // method properties ---------------------------------------------------------
-bool Cppyy::IsDeletedMethod(TCppMethod_t method)
+bool cppjit::interop::IsDeletedMethod(TCppMethod_t method)
 {
     return Cpp::IsFunctionDeleted(method);
 }
 
-bool Cppyy::IsPublicMethod(TCppMethod_t method)
+bool cppjit::interop::IsPublicMethod(TCppMethod_t method)
 {
     return Cpp::IsPublicMethod(method);
 }
 
-bool Cppyy::IsProtectedMethod(TCppMethod_t method)
+bool cppjit::interop::IsProtectedMethod(TCppMethod_t method)
 {
     return Cpp::IsProtectedMethod(method);
 }
 
-bool Cppyy::IsPrivateMethod(TCppMethod_t method)
+bool cppjit::interop::IsPrivateMethod(TCppMethod_t method)
 {
     return Cpp::IsPrivateMethod(method);
 }
 
-bool Cppyy::IsConstructor(TCppMethod_t method)
+bool cppjit::interop::IsConstructor(TCppMethod_t method)
 {
     return Cpp::IsConstructor(method);
 }
 
-bool Cppyy::IsDestructor(TCppMethod_t method)
+bool cppjit::interop::IsDestructor(TCppMethod_t method)
 {
     return Cpp::IsDestructor(method);
 }
 
-bool Cppyy::IsStaticMethod(TCppMethod_t method)
+bool cppjit::interop::IsStaticMethod(TCppMethod_t method)
 {
     return Cpp::IsStaticMethod(method);
 }
 
-bool Cppyy::IsExplicit(TCppMethod_t method)
+bool cppjit::interop::IsExplicit(TCppMethod_t method)
 {
     return Cpp::IsExplicit(method);
 }
 
 // data member reflection information ----------------------------------------
-void Cppyy::GetDatamembers(TCppScope_t scope, std::vector<TCppScope_t>& datamembers)
+void cppjit::interop::GetDatamembers(TCppScope_t scope, std::vector<TCppScope_t>& datamembers)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     Cpp::GetDatamembers(scope, datamembers);
@@ -1748,41 +1748,41 @@ void Cppyy::GetDatamembers(TCppScope_t scope, std::vector<TCppScope_t>& datamemb
     Cpp::GetEnumConstantDatamembers(scope, datamembers, false);
 }
 
-bool Cppyy::CheckDatamember(TCppScope_t scope, const std::string& name) {
+bool cppjit::interop::CheckDatamember(TCppScope_t scope, const std::string& name) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return (bool) Cpp::LookupDatamember(name, scope);
 }
 
-bool Cppyy::IsLambdaClass(TCppType_t type) {
+bool cppjit::interop::IsLambdaClass(TCppType_t type) {
     return Cpp::IsLambdaClass(type);
 }
 
-Cppyy::TCppScope_t Cppyy::WrapLambdaFromVariable(TCppScope_t var) {
+cppjit::interop::TCppScope_t cppjit::interop::WrapLambdaFromVariable(TCppScope_t var) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     std::ostringstream code;
-    std::string name = Cppyy::GetFinalName(var);
-    code << "namespace __cppyy_internal_wrap_g {\n"
+    std::string name = cppjit::interop::GetFinalName(var);
+    code << "namespace __cppjit_internal_wrap_g {\n"
       << "  " << "std::function " << name << " = ::" << Cpp::GetQualifiedName(var) << ";\n"
       << "}\n";
     
-    if (Cppyy::Compile(code.str().c_str())) {
+    if (cppjit::interop::Compile(code.str().c_str())) {
       TCppScope_t res = Cpp::GetNamed(
-          name, Cpp::GetScope("__cppyy_internal_wrap_g", /*parent=*/nullptr));
+          name, Cpp::GetScope("__cppjit_internal_wrap_g", /*parent=*/nullptr));
       if (res) return res;
     }
     return var;
 }
 
-Cppyy::TCppMethod_t Cppyy::AdaptFunctionForLambdaReturn(Cppyy::TCppMethod_t fn) {
+cppjit::interop::TCppMethod_t cppjit::interop::AdaptFunctionForLambdaReturn(cppjit::interop::TCppMethod_t fn) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
 
     std::string fn_name = Cpp::GetQualifiedCompleteName(TCppScope_t(fn.data));
-    std::string signature = Cppyy::GetMethodSignature(fn, true);
+    std::string signature = cppjit::interop::GetMethodSignature(fn, true);
 
     std::ostringstream call;
     call << "(";
-    for (size_t i = 0, n = Cppyy::GetMethodNumArgs(fn); i < n; i++) {
-        call << Cppyy::GetMethodArgName(fn, i);
+    for (size_t i = 0, n = cppjit::interop::GetMethodNumArgs(fn); i < n; i++) {
+        call << cppjit::interop::GetMethodArgName(fn, i);
         if (i != n - 1)
             call << ", ";
     }
@@ -1791,79 +1791,79 @@ Cppyy::TCppMethod_t Cppyy::AdaptFunctionForLambdaReturn(Cppyy::TCppMethod_t fn)
     std::ostringstream code;
     static int i = 0;
     std::string name = "lambda_return_convert_" + std::to_string(++i);
-        code << "namespace __cppyy_internal_wrap_g {\n"
+        code << "namespace __cppjit_internal_wrap_g {\n"
          << "auto " << name << signature << "{" << "return std::function(" << fn_name << call.str() << "); }\n"
          << "}\n";
-    if (Cppyy::Compile(code.str().c_str())) {
+    if (cppjit::interop::Compile(code.str().c_str())) {
       TCppScope_t res = Cpp::GetNamed(
-          name, Cpp::GetScope("__cppyy_internal_wrap_g", /*parent=*/nullptr));
+          name, Cpp::GetScope("__cppjit_internal_wrap_g", /*parent=*/nullptr));
       if (res) return TCppMethod_t(res.data);
     }
     return fn;
 }
 
-Cppyy::TCppType_t Cppyy::GetDatamemberType(TCppScope_t var)
+cppjit::interop::TCppType_t cppjit::interop::GetDatamemberType(TCppScope_t var)
 {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   return Cpp::GetVariableType(Cpp::GetUnderlyingScope(var));
 }
 
-std::string Cppyy::GetDatamemberTypeAsString(TCppScope_t scope)
+std::string cppjit::interop::GetDatamemberTypeAsString(TCppScope_t scope)
 {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   return Cpp::GetTypeAsString(
       Cpp::GetVariableType(Cpp::GetUnderlyingScope(scope)));
 }
 
-std::string Cppyy::GetTypeAsString(TCppType_t type)
+std::string cppjit::interop::GetTypeAsString(TCppType_t type)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetTypeAsString(type);
 }
 
-intptr_t Cppyy::GetDatamemberOffset(TCppScope_t var, TCppScope_t klass)
+intptr_t cppjit::interop::GetDatamemberOffset(TCppScope_t var, TCppScope_t klass)
 {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   return Cpp::GetVariableOffset(Cpp::GetUnderlyingScope(var), klass);
 }
 
 // data member properties ----------------------------------------------------
-bool Cppyy::IsPublicData(TCppScope_t datamem)
+bool cppjit::interop::IsPublicData(TCppScope_t datamem)
 {
     return Cpp::IsPublicVariable(datamem);
 }
 
-bool Cppyy::IsProtectedData(TCppScope_t datamem)
+bool cppjit::interop::IsProtectedData(TCppScope_t datamem)
 {
     return Cpp::IsProtectedVariable(datamem);
 }
 
-bool Cppyy::IsPrivateData(TCppScope_t datamem)
+bool cppjit::interop::IsPrivateData(TCppScope_t datamem)
 {
     return Cpp::IsPrivateVariable(datamem);
 }
 
-bool Cppyy::IsStaticDatamember(TCppScope_t var)
+bool cppjit::interop::IsStaticDatamember(TCppScope_t var)
 {
-  return Cpp::IsStaticVariable(Cppyy::GetUnderlyingScope(var));
+  return Cpp::IsStaticVariable(cppjit::interop::GetUnderlyingScope(var));
 }
 
-bool Cppyy::IsConstVar(TCppScope_t var)
+bool cppjit::interop::IsConstVar(TCppScope_t var)
 {
     return Cpp::IsConstVariable(var);
 }
 
-Cppyy::TCppMethod_t Cppyy::ReduceReturnType(TCppMethod_t fn, TCppType_t reduce) {
+cppjit::interop::TCppMethod_t cppjit::interop::ReduceReturnType(TCppMethod_t fn, TCppType_t reduce) {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
 
     std::string fn_name = Cpp::GetQualifiedCompleteName(TCppScope_t(fn.data));
-    std::string signature = Cppyy::GetMethodSignature(fn, true);
-    std::string result_type = Cppyy::GetTypeAsString(reduce);
+    std::string signature = cppjit::interop::GetMethodSignature(fn, true);
+    std::string result_type = cppjit::interop::GetTypeAsString(reduce);
 
     std::ostringstream call;
     call << "(";
-    for (size_t i = 0, n = Cppyy::GetMethodNumArgs(fn); i < n; i++) {
-        call << Cppyy::GetMethodArgName(fn, i);
+    for (size_t i = 0, n = cppjit::interop::GetMethodNumArgs(fn); i < n; i++) {
+        call << cppjit::interop::GetMethodArgName(fn, i);
         if (i != n - 1)
             call << ", ";
     }
@@ -1872,43 +1872,43 @@ Cppyy::TCppMethod_t Cppyy::ReduceReturnType(TCppMethod_t fn, TCppType_t reduce)
     std::ostringstream code;
     static int i = 0;
     std::string name = "reduced_function_" + std::to_string(++i);
-        code << "namespace __cppyy_internal_wrap_g {\n"
+        code << "namespace __cppjit_internal_wrap_g {\n"
          << result_type << " " << name << signature << "{" << "return (" << result_type << ")::" << fn_name << call.str() << "; }\n"
          << "}\n";
-    if (Cppyy::Compile(code.str().c_str())) {
+    if (cppjit::interop::Compile(code.str().c_str())) {
       TCppScope_t res = Cpp::GetNamed(
-          name, Cpp::GetScope("__cppyy_internal_wrap_g", /*parent=*/nullptr));
+          name, Cpp::GetScope("__cppjit_internal_wrap_g", /*parent=*/nullptr));
       if (res) return TCppMethod_t(res.data);
     }
     return fn;
 }
 
-std::vector<long int>  Cppyy::GetDimensions(TCppType_t type)
+std::vector<long int>  cppjit::interop::GetDimensions(TCppType_t type)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetDimensions(type);
 }
 
 // enum properties -----------------------------------------------------------
-std::vector<Cppyy::TCppScope_t> Cppyy::GetEnumConstants(TCppScope_t scope)
+std::vector<cppjit::interop::TCppScope_t> cppjit::interop::GetEnumConstants(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetEnumConstants(scope);
 }
 
-Cppyy::TCppType_t Cppyy::GetEnumConstantType(TCppScope_t scope)
+cppjit::interop::TCppType_t cppjit::interop::GetEnumConstantType(TCppScope_t scope)
 {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   return Cpp::GetEnumConstantType(Cpp::GetUnderlyingScope(scope));
 }
 
-Cppyy::TCppIndex_t Cppyy::GetEnumDataValue(TCppScope_t scope)
+cppjit::interop::TCppIndex_t cppjit::interop::GetEnumDataValue(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     return Cpp::GetEnumConstantValue(scope);
 }
 
-Cppyy::TCppScope_t Cppyy::InstantiateTemplate(
+cppjit::interop::TCppScope_t cppjit::interop::InstantiateTemplate(
              TCppScope_t tmpl, Cpp::TemplateArgInfo* args, size_t args_size)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
@@ -1916,7 +1916,7 @@ Cppyy::TCppScope_t Cppyy::InstantiateTemplate(
                                     /*instantiate_body=*/false);
 }
 
-void Cppyy::DumpScope(TCppScope_t scope)
+void cppjit::interop::DumpScope(TCppScope_t scope)
 {
     std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
     Cpp::DumpScope(scope);
diff --git a/src/CPyCppyy/src/API.cxx b/src/cpyrt/API.cxx
similarity index 84%
rename from src/CPyCppyy/src/API.cxx
rename to src/cpyrt/API.cxx
index 7c54dcf..adb176c 100644
--- a/src/CPyCppyy/src/API.cxx
+++ b/src/cpyrt/API.cxx
@@ -1,14 +1,14 @@
 // Bindings
-#include "CPyCppyy.h"
-#include "Cppyy.h"
-#define CPYCPPYY_INTERNAL 1
-#include "CPyCppyy/API.h"
-#undef CPYCPPYY_INTERNAL
+#include "cpyrt.h"
+#include "cppjit_interop.h"
+#define CPYRT_INTERNAL 1
+#include "cpyrt/API.h"
+#undef CPYRT_INTERNAL
 
 #include "CPPInstance.h"
 #include "CPPOverload.h"
 #include "CPPScope.h"
-#include "CPyCppyy/DispatchPtr.h"
+#include "cpyrt/DispatchPtr.h"
 #include "ProxyWrappers.h"
 #include "PyStrings.h"
 
@@ -18,10 +18,10 @@
 #include <string>
 
 //______________________________________________________________________________
-//                  CPyCppyy API: Interpreter and Proxy Access
+//                  cpyrt API: Interpreter and Proxy Access
 //                  ==========================================
 //
-// Access to cppyy Python objects from Cling and C++: allows conversion for
+// Access to cppjit Python objects from Cling and C++: allows conversion for
 // instances and type checking for scopes, instances, etc.
 // Adds a few convenience functions to call Python from Cling and expose Python
 // classes to Cling for use in inheritance etc.
@@ -30,7 +30,7 @@
 //- data ---------------------------------------------------------------------
 static PyObject* gMainDict = nullptr;
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     extern PyObject* gThisModule;
 }
 
@@ -41,7 +41,7 @@ namespace {
 static bool Initialize()
 {
 // Private initialization method: setup the python interpreter and load the
-// cppyy module.
+// cppjit module.
     static bool isInitialized = false;
     if (isInitialized)
         return true;
@@ -50,7 +50,7 @@ static bool Initialize()
     // this happens if Cling comes in first
         PyConfig config;
         PyConfig_InitPythonConfig(&config);
-        PyConfig_SetString(&config, &config.program_name, L"cppyy");
+        PyConfig_SetString(&config, &config.program_name, L"cppjit");
         Py_InitializeFromConfig(&config);
 
     // try again to see if the interpreter is initialized
@@ -60,12 +60,12 @@ static bool Initialize()
             return false;
         }
 
-    // force loading of the cppyy module
-        PyRun_SimpleString(const_cast<char*>("import cppyy"));
+    // force loading of the cppjit module
+        PyRun_SimpleString(const_cast<char*>("import cppjit"));
     }
 
     if (!gMainDict) {
-        CPyCppyy::PythonGILRAII python_gil_raii;
+        cppjit::cpyrt::PythonGILRAII python_gil_raii;
     // retrieve the main dictionary
         gMainDict = PyModule_GetDict(
             PyImport_AddModule(const_cast<char*>("__main__")));
@@ -83,20 +83,20 @@ static bool Initialize()
 } // unnamed namespace
 
 
-//- C++ access to cppyy objects ---------------------------------------------
-std::string CPyCppyy::Instance_GetScopedFinalName(PyObject* pyobject)
+//- C++ access to cppjit objects ---------------------------------------------
+std::string cppjit::cpyrt::Instance_GetScopedFinalName(PyObject* pyobject)
 {
    if (!Instance_Check(pyobject)) {
        PyErr_SetString(PyExc_TypeError, "Instance_GetScopedFinalName : object is not a C++ instance");
        return "";
    }
 
-   Cppyy::TCppScope_t pyobjectClass = ((CPPInstance *)pyobject)->ObjectIsA();
-   return Cppyy::GetScopedFinalName(pyobjectClass);
+   cppjit::interop::TCppScope_t pyobjectClass = ((CPPInstance *)pyobject)->ObjectIsA();
+   return cppjit::interop::GetScopedFinalName(pyobjectClass);
 }
 
 //-----------------------------------------------------------------------------
-void* CPyCppyy::Instance_AsVoidPtr(PyObject* pyobject)
+void* cppjit::cpyrt::Instance_AsVoidPtr(PyObject* pyobject)
 {
 // Extract the object pointer held by the CPPInstance pyobject.
     if (!Initialize())
@@ -113,7 +113,7 @@ void* CPyCppyy::Instance_AsVoidPtr(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-PyObject* CPyCppyy::Instance_FromVoidPtr(
+PyObject* cppjit::cpyrt::Instance_FromVoidPtr(
     void* addr, const std::string& classname, bool python_owns)
 {
 // Bind the addr to a python object of class defined by classname.
@@ -123,7 +123,7 @@ PyObject* CPyCppyy::Instance_FromVoidPtr(
     PythonGILRAII python_gil_raii;
 
 // perform cast (the call will check TClass and addr, and set python errors)
-    PyObject* pyobject = BindCppObjectNoCast(addr, Cppyy::GetScope(classname), false);
+    PyObject* pyobject = BindCppObjectNoCast(addr, cppjit::interop::GetScope(classname), false);
 
 // give ownership, for ref-counting, to the python side, if so requested
     if (python_owns && CPPInstance_Check(pyobject))
@@ -133,8 +133,8 @@ PyObject* CPyCppyy::Instance_FromVoidPtr(
 }
 
 //-----------------------------------------------------------------------------
-PyObject* CPyCppyy::Instance_FromVoidPtr(
-    void* addr, Cppyy::TCppScope_t klass_scope, bool python_owns)
+PyObject* cppjit::cpyrt::Instance_FromVoidPtr(
+    void* addr, cppjit::interop::TCppScope_t klass_scope, bool python_owns)
 {
 // Bind the addr to a python object of class defined by classname.
     if (!Initialize())
@@ -151,15 +151,15 @@ PyObject* CPyCppyy::Instance_FromVoidPtr(
 
     return pyobject;
 }
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 // version with C type arguments only for use with Numba
 PyObject* Instance_FromVoidPtr(void* addr, const char* classname, int python_owns) {
     return Instance_FromVoidPtr(addr, std::string(classname), (bool)python_owns);
 }
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Scope_Check(PyObject* pyobject)
+bool cppjit::cpyrt::Scope_Check(PyObject* pyobject)
 {
 // Test if the given object is of a CPPScope derived type.
     if (!Initialize())
@@ -170,7 +170,7 @@ bool CPyCppyy::Scope_Check(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Scope_CheckExact(PyObject* pyobject)
+bool cppjit::cpyrt::Scope_CheckExact(PyObject* pyobject)
 {
 // Test if the given object is of a CPPScope type.
     if (!Initialize())
@@ -181,7 +181,7 @@ bool CPyCppyy::Scope_CheckExact(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Instance_Check(PyObject* pyobject)
+bool cppjit::cpyrt::Instance_Check(PyObject* pyobject)
 {
 // Test if the given pyobject is of CPPInstance derived type.
     if (!Initialize())
@@ -193,7 +193,7 @@ bool CPyCppyy::Instance_Check(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Instance_CheckExact(PyObject* pyobject)
+bool cppjit::cpyrt::Instance_CheckExact(PyObject* pyobject)
 {
 // Test if the given pyobject is of CPPInstance type.
     if (!Initialize())
@@ -205,7 +205,7 @@ bool CPyCppyy::Instance_CheckExact(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::Instance_SetPythonOwns(PyObject* pyobject)
+void cppjit::cpyrt::Instance_SetPythonOwns(PyObject* pyobject)
 {
     if (!Initialize())
         return;
@@ -218,7 +218,7 @@ void CPyCppyy::Instance_SetPythonOwns(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::Instance_SetCppOwns(PyObject* pyobject)
+void cppjit::cpyrt::Instance_SetCppOwns(PyObject* pyobject)
 {
     if (!Initialize())
         return;
@@ -231,7 +231,7 @@ void CPyCppyy::Instance_SetCppOwns(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Sequence_Check(PyObject* pyobject)
+bool cppjit::cpyrt::Sequence_Check(PyObject* pyobject)
 {
     PythonGILRAII python_gil_raii;
 // Extends on PySequence_Check() to determine whether an object can be iterated
@@ -265,7 +265,7 @@ bool CPyCppyy::Sequence_Check(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Instance_IsLively(PyObject* pyobject)
+bool cppjit::cpyrt::Instance_IsLively(PyObject* pyobject)
 {
     PythonGILRAII python_gil_raii;
 // Test whether the given instance can safely return to C++
@@ -281,7 +281,7 @@ bool CPyCppyy::Instance_IsLively(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Overload_Check(PyObject* pyobject)
+bool cppjit::cpyrt::Overload_Check(PyObject* pyobject)
 {
 // Test if the given pyobject is of CPPOverload derived type.
     if (!Initialize())
@@ -293,7 +293,7 @@ bool CPyCppyy::Overload_Check(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Overload_CheckExact(PyObject* pyobject)
+bool cppjit::cpyrt::Overload_CheckExact(PyObject* pyobject)
 {
 // Test if the given pyobject is of CPPOverload type.
     if (!Initialize())
@@ -305,13 +305,13 @@ bool CPyCppyy::Overload_CheckExact(PyObject* pyobject)
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::Instance_SetReduceMethod(PyCFunction reduceMethod)
+void cppjit::cpyrt::Instance_SetReduceMethod(PyCFunction reduceMethod)
 {
     CPPInstance::ReduceMethod() = reduceMethod;
 }
 
 //- access to the python interpreter ----------------------------------------
-bool CPyCppyy::Import(const std::string& mod_name)
+bool cppjit::cpyrt::Import(const std::string& mod_name)
 {
 // Import the named python module and create Cling equivalents for its classes.
     if (!Initialize())
@@ -330,7 +330,7 @@ bool CPyCppyy::Import(const std::string& mod_name)
     PyModule_AddObject(gThisModule, mod_name.c_str(), mod);
 
 // force creation of the module as a namespace
-// TODO: the following is broken (and should live in Cppyy.cxx)
+// TODO: the following is broken (and should live in cppjit_interop.cxx)
 //   TClass::GetClass(mod_name, true);
 
     PyObject* dct = PyModule_GetDict(mod);
@@ -351,7 +351,7 @@ bool CPyCppyy::Import(const std::string& mod_name)
         // build full, qualified name
             std::string fullname = mod_name;
             fullname += ".";
-            fullname += CPyCppyy_PyText_AsString(pyClName);
+            fullname += cpyrt_PyText_AsString(pyClName);
 
             Py_XDECREF(pyClName);
         }
@@ -368,12 +368,12 @@ bool CPyCppyy::Import(const std::string& mod_name)
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::ExecScript(const std::string& name, const std::vector<std::string>& args)
+void cppjit::cpyrt::ExecScript(const std::string& name, const std::vector<std::string>& args)
 {
 // Execute a python stand-alone script, with argv CLI arguments.
 //
 // example of use:
-//    CPyCppyy::ExecScript("test.py", {"1", "2", "3"});
+//    cppjit::cpyrt::ExecScript("test.py", {"1", "2", "3"});
 
     if (!Initialize())
         return;
@@ -447,7 +447,7 @@ void CPyCppyy::ExecScript(const std::string& name, const std::vector<std::string
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::Exec(const std::string& cmd)
+bool cppjit::cpyrt::Exec(const std::string& cmd)
 {
 // Execute a python statement (e.g. "import noddy").
     if (!Initialize())
@@ -469,7 +469,7 @@ bool CPyCppyy::Exec(const std::string& cmd)
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::Prompt() {
+void cppjit::cpyrt::Prompt() {
 // Enter an interactive python session (exit with ^D). State is preserved
 // between successive calls.
     if (!Initialize())
diff --git a/src/CPyCppyy/include/CPyCppyy/API.h b/src/cpyrt/API.h
similarity index 60%
rename from src/CPyCppyy/include/CPyCppyy/API.h
rename to src/cpyrt/API.h
index 8f17b0f..1728371 100644
--- a/src/CPyCppyy/include/CPyCppyy/API.h
+++ b/src/cpyrt/API.h
@@ -1,8 +1,8 @@
-#ifndef CPYCPPYY_API_H
-#define CPYCPPYY_API_H
+#ifndef CPYRT_API_H
+#define CPYRT_API_H
 
 //
-// Access to the python interpreter and API onto CPyCppyy.
+// Access to the python interpreter and API onto cpyrt.
 //
 
 // Python
@@ -25,10 +25,10 @@
 #endif
 #include "Python.h"
 
-#define CPYCPPYY_VERSION_HEX 0x011200
+#define CPYRT_VERSION_HEX 0x011200
 
-// Cppyy types
-#ifndef CPYCPPYY_INTERNAL
+// cppjit_interop types
+#ifndef CPYRT_INTERNAL
 
 namespace Cpp {
 struct DeclRef;
@@ -37,30 +37,30 @@ struct FuncRef;
 struct ObjectRef;
 }  // namespace Cpp
 
-namespace Cppyy {
+namespace cppjit::interop {
 typedef Cpp::DeclRef TCppScope_t;
 typedef Cpp::TypeRef TCppType_t;
 typedef Cpp::ObjectRef TCppObject_t;
 typedef Cpp::FuncRef TCppMethod_t;
 typedef size_t TCppIndex_t;
 typedef void* TCppFuncAddr_t;
-} // namespace Cppyy
+} // namespace cppjit::interop
 #endif
 
 // Bindings
-#include "CPyCppyy/CommonDefs.h"
+#include "cpyrt/CommonDefs.h"
 
 // Standard
 #include <string>
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 //- type conversion ---------------------------------------------------------
 
-#ifndef CPYCPPYY_PARAMETER
-#define CPYCPPYY_PARAMETER
+#ifndef CPYRT_PARAMETER
+#define CPYRT_PARAMETER
 // generic function argument type
 struct Parameter {
     union Value {
@@ -86,14 +86,14 @@ struct Parameter {
     void* fRef;
     char  fTypeCode;
 };
-#endif // CPYCPPYY_PARAMETER
+#endif // CPYRT_PARAMETER
 
 // CallContext is not currently exposed
 struct CallContext;
 
 // Dimensions class not currently exposed
-#ifndef CPYCPPYY_DIMENSIONS_H
-#define CPYCPPYY_DIMENSIONS_H
+#ifndef CPYRT_DIMENSIONS_H
+#define CPYRT_DIMENSIONS_H
 typedef Py_ssize_t dim_t;
 
 class Dimensions {      // Windows note: NOT exported/imported
@@ -109,10 +109,10 @@ class Dimensions {      // Windows note: NOT exported/imported
 
 typedef Dimensions dims_t;
 typedef const dims_t& cdims_t;
-#endif // !CPYCPPYY_DIMENSIONS_H
+#endif // !CPYRT_DIMENSIONS_H
 
 // type converter base class
-class CPYCPPYY_CLASS_EXTERN Converter {
+class CPYRT_CLASS_EXTERN Converter {
 public:
     virtual ~Converter();
 
@@ -130,113 +130,113 @@ class CPYCPPYY_CLASS_EXTERN Converter {
 };
 
 // create a converter based on its full type name and dimensions
-CPYCPPYY_EXTERN Converter* CreateConverter(const std::string& name, cdims_t = 0);
-CPYCPPYY_EXTERN Converter* CreateConverter(Cppyy::TCppType_t type, cdims_t = 0);
+CPYRT_EXTERN Converter* CreateConverter(const std::string& name, cdims_t = 0);
+CPYRT_EXTERN Converter* CreateConverter(cppjit::interop::TCppType_t type, cdims_t = 0);
 
 // delete a previously created converter
-CPYCPPYY_EXTERN void DestroyConverter(Converter* p);
+CPYRT_EXTERN void DestroyConverter(Converter* p);
 
 // register a custom converter
 typedef Converter* (*ConverterFactory_t)(cdims_t);
-CPYCPPYY_EXTERN bool RegisterConverter(const std::string& name, ConverterFactory_t);
+CPYRT_EXTERN bool RegisterConverter(const std::string& name, ConverterFactory_t);
 
 // register a custom converter that is a reference to an existing converter
-CPYCPPYY_EXTERN bool RegisterConverterAlias(const std::string& name, const std::string& target);
+CPYRT_EXTERN bool RegisterConverterAlias(const std::string& name, const std::string& target);
 
 // remove a custom converter
-CPYCPPYY_EXTERN bool UnregisterConverter(const std::string& name);
+CPYRT_EXTERN bool UnregisterConverter(const std::string& name);
 
 
 // function executor base class
-class CPYCPPYY_CLASS_EXTERN Executor {
+class CPYRT_CLASS_EXTERN Executor {
 public:
     virtual ~Executor();
 
 // callback when executing a function from Python
     virtual PyObject* Execute(
-        Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*) = 0;
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) = 0;
 
 // if an executor has state, it will be unique per function, shared otherwise
     virtual bool HasState() { return false; }
 };
 
 // create an executor based on its full type name
-CPYCPPYY_EXTERN Executor* CreateExecutor(const std::string& name, cdims_t = 0);
-CPYCPPYY_EXTERN Executor* CreateExecutor(Cppyy::TCppType_t type, cdims_t = 0);
+CPYRT_EXTERN Executor* CreateExecutor(const std::string& name, cdims_t = 0);
+CPYRT_EXTERN Executor* CreateExecutor(cppjit::interop::TCppType_t type, cdims_t = 0);
 
 // delete a previously created executor
-CPYCPPYY_EXTERN void DestroyConverter(Converter* p);
+CPYRT_EXTERN void DestroyConverter(Converter* p);
 
 // register a custom executor
 typedef Executor* (*ExecutorFactory_t)(cdims_t);
-CPYCPPYY_EXTERN bool RegisterExecutor(const std::string& name, ExecutorFactory_t);
+CPYRT_EXTERN bool RegisterExecutor(const std::string& name, ExecutorFactory_t);
 
 // register a custom executor that is a reference to an existing converter
-CPYCPPYY_EXTERN bool RegisterExecutorAlias(const std::string& name, const std::string& target);
+CPYRT_EXTERN bool RegisterExecutorAlias(const std::string& name, const std::string& target);
 
 // remove a custom executor
-CPYCPPYY_EXTERN bool UnregisterExecutor(const std::string& name);
+CPYRT_EXTERN bool UnregisterExecutor(const std::string& name);
 
 // helper for calling into C++ from a custom executor
-CPYCPPYY_EXTERN void* CallVoidP(Cppyy::TCppMethod_t, Cppyy::TCppObject_t, CallContext*);
+CPYRT_EXTERN void* CallVoidP(cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*);
 
 
-//- C++ access to cppyy objects ---------------------------------------------
+//- C++ access to cppjit objects ---------------------------------------------
 
 // Get C++ Instance (python object proxy) name.
 // Sets a TypeError and returns an empty string if the pyobject is not a CPPInstance.
-CPYCPPYY_EXTERN std::string Instance_GetScopedFinalName(PyObject* pyobject);
+CPYRT_EXTERN std::string Instance_GetScopedFinalName(PyObject* pyobject);
 
 // C++ Instance (python object proxy) to void* conversion
-CPYCPPYY_EXTERN void* Instance_AsVoidPtr(PyObject* pyobject);
+CPYRT_EXTERN void* Instance_AsVoidPtr(PyObject* pyobject);
 
 // void* to C++ Instance (python object proxy) conversion, returns a new reference
-CPYCPPYY_EXTERN PyObject* Instance_FromVoidPtr(
+CPYRT_EXTERN PyObject* Instance_FromVoidPtr(
     void* addr, const std::string& classname, bool python_owns = false);
-CPYCPPYY_EXTERN PyObject* Instance_FromVoidPtr(
-    void* addr, Cppyy::TCppScope_t klass_scope, bool python_owns = false);
+CPYRT_EXTERN PyObject* Instance_FromVoidPtr(
+    void* addr, cppjit::interop::TCppScope_t klass_scope, bool python_owns = false);
 // type verifiers for C++ Scope
-CPYCPPYY_EXTERN bool Scope_Check(PyObject* pyobject);
-CPYCPPYY_EXTERN bool Scope_CheckExact(PyObject* pyobject);
+CPYRT_EXTERN bool Scope_Check(PyObject* pyobject);
+CPYRT_EXTERN bool Scope_CheckExact(PyObject* pyobject);
 
 // type verifiers for C++ Instance
-CPYCPPYY_EXTERN bool Instance_Check(PyObject* pyobject);
-CPYCPPYY_EXTERN bool Instance_CheckExact(PyObject* pyobject);
+CPYRT_EXTERN bool Instance_Check(PyObject* pyobject);
+CPYRT_EXTERN bool Instance_CheckExact(PyObject* pyobject);
 
 // memory management: ownership of the underlying C++ object
-CPYCPPYY_EXTERN void Instance_SetPythonOwns(PyObject* pyobject);
-CPYCPPYY_EXTERN void Instance_SetCppOwns(PyObject* pyobject);
+CPYRT_EXTERN void Instance_SetPythonOwns(PyObject* pyobject);
+CPYRT_EXTERN void Instance_SetCppOwns(PyObject* pyobject);
 
 // type verifier for sequences
-CPYCPPYY_EXTERN bool Sequence_Check(PyObject* pyobject);
+CPYRT_EXTERN bool Sequence_Check(PyObject* pyobject);
 
 // helper to verify expected safety of moving an instance into C++
-CPYCPPYY_EXTERN bool Instance_IsLively(PyObject* pyobject);
+CPYRT_EXTERN bool Instance_IsLively(PyObject* pyobject);
 
 // type verifiers for C++ Overload
-CPYCPPYY_EXTERN bool Overload_Check(PyObject* pyobject);
-CPYCPPYY_EXTERN bool Overload_CheckExact(PyObject* pyobject);
+CPYRT_EXTERN bool Overload_Check(PyObject* pyobject);
+CPYRT_EXTERN bool Overload_CheckExact(PyObject* pyobject);
 
 // Sets the __reduce__ method for the CPPInstance class, which is by default not
-// implemented by cppyy but might make sense to implement by frameworks that
+// implemented by cppjit but might make sense to implement by frameworks that
 // support IO of arbitrary C++ objects, like ROOT.
-CPYCPPYY_EXTERN void Instance_SetReduceMethod(PyCFunction reduceMethod);
+CPYRT_EXTERN void Instance_SetReduceMethod(PyCFunction reduceMethod);
 
 
 //- access to the python interpreter ----------------------------------------
 
 // import a python module, making its classes available to Cling
-CPYCPPYY_EXTERN bool Import(const std::string& name);
+CPYRT_EXTERN bool Import(const std::string& name);
 
 // execute a python statement (e.g. "import sys")
-CPYCPPYY_EXTERN bool Exec(const std::string& cmd);
+CPYRT_EXTERN bool Exec(const std::string& cmd);
 
 // execute a python stand-alone script, with argv CLI arguments
-CPYCPPYY_EXTERN void ExecScript(const std::string& name, const std::vector<std::string>& args);
+CPYRT_EXTERN void ExecScript(const std::string& name, const std::vector<std::string>& args);
 
 // enter an interactive python session (exit with ^D)
-CPYCPPYY_EXTERN void Prompt();
+CPYRT_EXTERN void Prompt();
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_API_H
+#endif // !CPYRT_API_H
diff --git a/src/CPyCppyy/src/CPPClassMethod.cxx b/src/cpyrt/CPPClassMethod.cxx
similarity index 75%
rename from src/CPyCppyy/src/CPPClassMethod.cxx
rename to src/cpyrt/CPPClassMethod.cxx
index 9134d5a..e7af683 100644
--- a/src/CPyCppyy/src/CPPClassMethod.cxx
+++ b/src/cpyrt/CPPClassMethod.cxx
@@ -1,11 +1,11 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPClassMethod.h"
 #include "CPPInstance.h"
 
 
 //- public members --------------------------------------------------------------
-PyObject *CPyCppyy::CPPClassMethod::Call(CPPInstance *&self, CPyCppyy_PyArgs_t args,
+PyObject *cppjit::cpyrt::CPPClassMethod::Call(CPPInstance *&self, cpyrt_PyArgs_t args,
                                          size_t nargsf, PyObject *kwds, CallContext *ctxt)
 {
 // preliminary check in case keywords are accidently used (they are ignored otherwise)
@@ -27,11 +27,11 @@ PyObject *CPyCppyy::CPPClassMethod::Call(CPPInstance *&self, CPyCppyy_PyArgs_t a
 // As-is, if no suitable `self` is given (normal case), but the type of the first argument
 // matches the enclosing scope of the class method and it isn't needed for the call, then
 // assume that the method was (incorrectly) bound and so drop that instance from args.
-    int nargs = (int)CPyCppyy_PyArgs_GET_SIZE(args, nargsf);
+    int nargs = (int)cpyrt_PyArgs_GET_SIZE(args, nargsf);
     if ((!self || (PyObject*)self == Py_None) && nargs) {
-        PyObject* arg0 = CPyCppyy_PyArgs_GET_ITEM(args, 0);
+        PyObject* arg0 = cpyrt_PyArgs_GET_ITEM(args, 0);
         if (CPPInstance_Check(arg0) && fArgsRequired <= nargs - 1 &&
-            Cppyy::IsSubclass(reinterpret_cast<CPPInstance *>(arg0)->ObjectIsA(), GetScope())) {
+            cppjit::interop::IsSubclass(reinterpret_cast<CPPInstance *>(arg0)->ObjectIsA(), GetScope())) {
             args   += 1;     // drops first argument
             nargsf -= 1;
         }
@@ -45,9 +45,9 @@ PyObject *CPyCppyy::CPPClassMethod::Call(CPPInstance *&self, CPyCppyy_PyArgs_t a
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPClassMethod::GetTypeName()
+PyObject* cppjit::cpyrt::CPPClassMethod::GetTypeName()
 {
-    PyObject* cppname = CPyCppyy_PyText_FromString((GetReturnTypeName() + " (*)").c_str());
-    CPyCppyy_PyText_AppendAndDel(&cppname, GetSignature(false /* show_formalargs */));
+    PyObject* cppname = cpyrt_PyText_FromString((GetReturnTypeName() + " (*)").c_str());
+    cpyrt_PyText_AppendAndDel(&cppname, GetSignature(false /* show_formalargs */));
     return cppname;
 }
diff --git a/src/CPyCppyy/src/CPPClassMethod.h b/src/cpyrt/CPPClassMethod.h
similarity index 53%
rename from src/CPyCppyy/src/CPPClassMethod.h
rename to src/cpyrt/CPPClassMethod.h
index c8c3e85..420054b 100644
--- a/src/CPyCppyy/src/CPPClassMethod.h
+++ b/src/cpyrt/CPPClassMethod.h
@@ -1,11 +1,11 @@
-#ifndef CPYCPPYY_CPPCLASSMETHOD_H
-#define CPYCPPYY_CPPCLASSMETHOD_H
+#ifndef CPYRT_CPPCLASSMETHOD_H
+#define CPYRT_CPPCLASSMETHOD_H
 
 // Bindings
 #include "CPPMethod.h"
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class CPPClassMethod : public CPPMethod {
 public:
@@ -17,9 +17,9 @@ class CPPClassMethod : public CPPMethod {
 public:
     PyCallable* Clone() override { return new CPPClassMethod(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPCLASSMETHOD_H
+#endif // !CPYRT_CPPCLASSMETHOD_H
diff --git a/src/CPyCppyy/src/CPPConstructor.cxx b/src/cpyrt/CPPConstructor.cxx
similarity index 77%
rename from src/CPyCppyy/src/CPPConstructor.cxx
rename to src/cpyrt/CPPConstructor.cxx
index 7b6170f..7663faf 100644
--- a/src/CPyCppyy/src/CPPConstructor.cxx
+++ b/src/cpyrt/CPPConstructor.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPConstructor.h"
 #include "CPPInstance.h"
 #include "Executors.h"
@@ -13,15 +13,15 @@
 
 
 //- data _____________________________________________________________________
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     extern PyObject* gNullPtrObject;
     void* Instance_AsVoidPtr(PyObject* pyobject);
-    PyObject* Instance_FromVoidPtr(void* addr, Cppyy::TCppScope_t klass_scope, bool python_owns);
+    PyObject* Instance_FromVoidPtr(void* addr, cppjit::interop::TCppScope_t klass_scope, bool python_owns);
 }
 
 
 //- protected members --------------------------------------------------------
-bool CPyCppyy::CPPConstructor::InitExecutor_(Executor*& executor, CallContext*)
+bool cppjit::cpyrt::CPPConstructor::InitExecutor_(Executor*& executor, CallContext*)
 {
 // pick up special case new object executor
     executor = CreateExecutor("__init__");
@@ -29,34 +29,34 @@ bool CPyCppyy::CPPConstructor::InitExecutor_(Executor*& executor, CallContext*)
 }
 
 //- public members -----------------------------------------------------------
-PyObject* CPyCppyy::CPPConstructor::GetDocString()
+PyObject* cppjit::cpyrt::CPPConstructor::GetDocString()
 {
 // GetMethod() may return an empty function if this is just a special case place holder
-    const std::string& clName = Cppyy::GetFinalName(this->GetScope());
-    return CPyCppyy_PyText_FromFormat("%s::%s%s",
+    const std::string& clName = cppjit::interop::GetFinalName(this->GetScope());
+    return cpyrt_PyText_FromFormat("%s::%s%s",
         clName.c_str(), clName.c_str(), this->GetMethod() ? this->GetSignatureString().c_str() : "()");
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPConstructor::Reflex(
-    Cppyy::Reflex::RequestId_t request, Cppyy::Reflex::FormatId_t format)
+PyObject* cppjit::cpyrt::CPPConstructor::Reflex(
+    cppjit::interop::Reflex::RequestId_t request, cppjit::interop::Reflex::FormatId_t format)
 {
 // C++ reflection tooling for constructors.
 
-    if (request == Cppyy::Reflex::RETURN_TYPE) {
-        std::string fn = Cppyy::GetScopedFinalName(this->GetScope());
-        if (format == Cppyy::Reflex::OPTIMAL || format == Cppyy::Reflex::AS_TYPE)
+    if (request == cppjit::interop::Reflex::RETURN_TYPE) {
+        std::string fn = cppjit::interop::GetScopedFinalName(this->GetScope());
+        if (format == cppjit::interop::Reflex::OPTIMAL || format == cppjit::interop::Reflex::AS_TYPE)
             return CreateScopeProxy(this->GetScope());
-        else if (format == Cppyy::Reflex::AS_STRING)
-            return CPyCppyy_PyText_FromString(fn.c_str());
+        else if (format == cppjit::interop::Reflex::AS_STRING)
+            return cpyrt_PyText_FromString(fn.c_str());
     }
 
     return PyCallable::Reflex(request, format);
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPConstructor::Call(CPPInstance*& self,
-    CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CPPConstructor::Call(CPPInstance*& self,
+    cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
 {
 // setup as necessary
     if (fArgsRequired == -1 && !this->Initialize(ctxt))
@@ -83,9 +83,9 @@ PyObject* CPyCppyy::CPPConstructor::Call(CPPInstance*& self,
 
 // Do nothing if the constructor is explicit and we are in an implicit
 // conversion context. See also the ConvertImplicit() helper in Converters.cxx.
-    if((cppScopeFlags & CPPScope::kActiveImplicitCall) && Cppyy::IsExplicit(GetMethod())) {
+    if((cppScopeFlags & CPPScope::kActiveImplicitCall) && cppjit::interop::IsExplicit(GetMethod())) {
         // FIXME: Cases with explicit marked std::complex constructors where we expect implicit conversionss
-        if (Cppyy::GetMethodSignature(GetMethod(), true).find("std::complex") == std::string::npos)
+        if (cppjit::interop::GetMethodSignature(GetMethod(), true).find("std::complex") == std::string::npos)
             return nullptr;
     }
 
@@ -94,7 +94,7 @@ PyObject* CPyCppyy::CPPConstructor::Call(CPPInstance*& self,
         ctxt->fPyContext = (PyObject*)cargs.fSelf;    // no Py_INCREF as no ownership
 
 // perform the call, nullptr 'this' makes the other side allocate the memory
-    Cppyy::TCppScope_t disp = self->ObjectIsA(false /* check_smart */);
+    cppjit::interop::TCppScope_t disp = self->ObjectIsA(false /* check_smart */);
     intptr_t address = 0;
     if (GetScope() != disp) {
     // happens for Python derived types (which have a dispatcher inserted that
@@ -109,7 +109,7 @@ PyObject* CPyCppyy::CPPConstructor::Call(CPPInstance*& self,
         }
 
     // get the dispatcher class and verify
-        PyObject* dispproxy = CPyCppyy::GetScopeProxy(disp);
+        PyObject* dispproxy = cppjit::cpyrt::GetScopeProxy(disp);
         if (!dispproxy) {
             PyErr_SetString(PyExc_TypeError, "dispatcher proxy was never created");
             return nullptr;
@@ -117,11 +117,11 @@ PyObject* CPyCppyy::CPPConstructor::Call(CPPInstance*& self,
 
         if (!(((CPPClass*)dispproxy)->fFlags & CPPScope::kIsPython)) {
             PyErr_SetString(PyExc_TypeError, const_cast<char*>((
-                "constructor for " + Cppyy::GetScopedFinalName(disp) + " is not a dispatcher").c_str()));
+                "constructor for " + cppjit::interop::GetScopedFinalName(disp) + " is not a dispatcher").c_str()));
             return nullptr;
         }
 
-        PyObject* pyobj = CPyCppyy_PyObject_Call(dispproxy, cargs.fArgs, cargs.fNArgsf, kwds);
+        PyObject* pyobj = cpyrt_PyObject_Call(dispproxy, cargs.fArgs, cargs.fNArgsf, kwds);
         if (!pyobj)
             return nullptr;
 
@@ -156,7 +156,7 @@ PyObject* CPyCppyy::CPPConstructor::Call(CPPInstance*& self,
     // mark as actual to prevent needless auto-casting and register on its class
         self->fFlags |= CPPInstance::kIsActual;
         if (!(((CPPClass*)Py_TYPE(self))->fFlags & CPPScope::kIsSmart))
-            MemoryRegulator::RegisterPyObject(self, Cppyy::TCppObject_t((void*)address));
+            MemoryRegulator::RegisterPyObject(self, cppjit::interop::TCppObject_t((void*)address));
 
     // handling smart types this way is deeply fugly, but if CPPInstance sets the proper
     // types in op_new first, then the wrong init is called
@@ -177,7 +177,7 @@ PyObject* CPyCppyy::CPPConstructor::Call(CPPInstance*& self,
 
     if (!PyErr_Occurred())   // should be set, otherwise write a generic error msg
         PyErr_SetString(PyExc_TypeError, const_cast<char*>(
-            (Cppyy::GetScopedFinalName(GetScope()) + " constructor failed").c_str()));
+            (cppjit::interop::GetScopedFinalName(GetScope()) + " constructor failed").c_str()));
 
 // do not throw an exception, nullptr might trigger the overload handler to
 // choose a different constructor, which if all fails will throw an exception
@@ -186,20 +186,20 @@ PyObject* CPyCppyy::CPPConstructor::Call(CPPInstance*& self,
 
 
 //----------------------------------------------------------------------------
-CPyCppyy::CPPMultiConstructor::CPPMultiConstructor(Cppyy::TCppScope_t scope, Cppyy::TCppMethod_t method) :
+cppjit::cpyrt::CPPMultiConstructor::CPPMultiConstructor(cppjit::interop::TCppScope_t scope, cppjit::interop::TCppMethod_t method) :
     CPPConstructor(scope, method)
 {
-    fNumBases = Cppyy::GetNumBases(scope);
+    fNumBases = cppjit::interop::GetNumBases(scope);
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::CPPMultiConstructor::CPPMultiConstructor(const CPPMultiConstructor& s) :
+cppjit::cpyrt::CPPMultiConstructor::CPPMultiConstructor(const CPPMultiConstructor& s) :
     CPPConstructor(s), fNumBases(s.fNumBases)
 {
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::CPPMultiConstructor& CPyCppyy::CPPMultiConstructor::operator=(const CPPMultiConstructor& s)
+cppjit::cpyrt::CPPMultiConstructor& cppjit::cpyrt::CPPMultiConstructor::operator=(const CPPMultiConstructor& s)
 {
     if (this != &s) {
         CPPConstructor::operator=(s);
@@ -209,8 +209,8 @@ CPyCppyy::CPPMultiConstructor& CPyCppyy::CPPMultiConstructor::operator=(const CP
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPMultiConstructor::Call(CPPInstance*& self,
-    CPyCppyy_PyArgs_t argsin, size_t nargsf, PyObject* kwds, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CPPMultiConstructor::Call(CPPInstance*& self,
+    cpyrt_PyArgs_t argsin, size_t nargsf, PyObject* kwds, CallContext* ctxt)
 {
 // By convention, initialization parameters of multiple base classes are grouped
 // by target base class. Here, we disambiguate and put in "sentinel" parameters
@@ -233,7 +233,7 @@ PyObject* CPyCppyy::CPPMultiConstructor::Call(CPPInstance*& self,
 
 // to re-use the argument handling, simply change the argument array into a tuple (the
 // benefits of not allocating the tuple are relatively minor in this case)
-    Py_ssize_t nargs = CPyCppyy_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
+    Py_ssize_t nargs = cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
     PyObject* args = PyTuple_New(nargs);
     for (Py_ssize_t i = 0; i < nargs; ++i) {
         Py_INCREF(cargs.fArgs[i]);
@@ -311,7 +311,7 @@ PyObject* CPyCppyy::CPPMultiConstructor::Call(CPPInstance*& self,
     auto argsu = std::unique_ptr<PyObject*[]>{new PyObject*[nargs]};
     for (Py_ssize_t i = 0; i < nargs; ++i)
         argsu[i] = PyTuple_GET_ITEM(args, i);
-    CPyCppyy_PyArgs_t _args = argsu.get();
+    cpyrt_PyArgs_t _args = argsu.get();
 
     PyObject* result = CPPConstructor::Call(self, _args, nargs, kwds, ctxt);
     Py_DECREF(args);
@@ -321,13 +321,13 @@ PyObject* CPyCppyy::CPPMultiConstructor::Call(CPPInstance*& self,
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPAbstractClassConstructor::Call(CPPInstance*& self,
-    CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CPPAbstractClassConstructor::Call(CPPInstance*& self,
+    cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
 {
 // do not allow instantiation of abstract classes
     if ((self && GetScope() != self->ObjectIsA()
         ) || (!self && !(ctxt->fFlags & CallContext::kFromDescr) && \
-              CPyCppyy_PyArgs_GET_SIZE(args, nargsf) && CPPInstance_Check(args[0]) && \
+              cpyrt_PyArgs_GET_SIZE(args, nargsf) && CPPInstance_Check(args[0]) && \
               GetScope() != ((CPPInstance*)args[0])->ObjectIsA()
         )) {
     // happens if a dispatcher is inserted; allow constructor call
@@ -336,38 +336,38 @@ PyObject* CPyCppyy::CPPAbstractClassConstructor::Call(CPPInstance*& self,
 
     PyErr_Format(PyExc_TypeError, "cannot instantiate abstract class \'%s\'"
             " (from derived classes, use super() instead)",
-        Cppyy::GetScopedFinalName(this->GetScope()).c_str());
+        cppjit::interop::GetScopedFinalName(this->GetScope()).c_str());
     return nullptr;
 }
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPNamespaceConstructor::Call(
-    CPPInstance*&, CPyCppyy_PyArgs_t, size_t, PyObject*, CallContext*)
+PyObject* cppjit::cpyrt::CPPNamespaceConstructor::Call(
+    CPPInstance*&, cpyrt_PyArgs_t, size_t, PyObject*, CallContext*)
 {
 // do not allow instantiation of namespaces
     PyErr_Format(PyExc_TypeError, "cannot instantiate namespace \'%s\'",
-        Cppyy::GetScopedFinalName(this->GetScope()).c_str());
+        cppjit::interop::GetScopedFinalName(this->GetScope()).c_str());
     return nullptr;
 }
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPIncompleteClassConstructor::Call(
-    CPPInstance*&, CPyCppyy_PyArgs_t, size_t, PyObject*, CallContext*)
+PyObject* cppjit::cpyrt::CPPIncompleteClassConstructor::Call(
+    CPPInstance*&, cpyrt_PyArgs_t, size_t, PyObject*, CallContext*)
 {
 // do not allow instantiation of incomplete (forward declared) classes)
     PyErr_Format(PyExc_TypeError, "cannot instantiate incomplete class \'%s\'",
-        Cppyy::GetScopedFinalName(this->GetScope()).c_str());
+        cppjit::interop::GetScopedFinalName(this->GetScope()).c_str());
     return nullptr;
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPAllPrivateClassConstructor::Call(
-    CPPInstance*&, CPyCppyy_PyArgs_t, size_t, PyObject*, CallContext*)
+PyObject* cppjit::cpyrt::CPPAllPrivateClassConstructor::Call(
+    CPPInstance*&, cpyrt_PyArgs_t, size_t, PyObject*, CallContext*)
 {
 // do not allow instantiation of classes with only private constructors
     PyErr_Format(PyExc_TypeError, "cannot instantiate class \'%s\' that has no public constructors",
-        Cppyy::GetScopedFinalName(this->GetScope()).c_str());
+        cppjit::interop::GetScopedFinalName(this->GetScope()).c_str());
     return nullptr;
 }
diff --git a/src/CPyCppyy/src/CPPConstructor.h b/src/cpyrt/CPPConstructor.h
similarity index 64%
rename from src/CPyCppyy/src/CPPConstructor.h
rename to src/cpyrt/CPPConstructor.h
index 6313fb9..fe9f06e 100644
--- a/src/CPyCppyy/src/CPPConstructor.h
+++ b/src/cpyrt/CPPConstructor.h
@@ -1,11 +1,11 @@
-#ifndef CPYCPPYY_CPPCONSTRUCTOR_H
-#define CPYCPPYY_CPPCONSTRUCTOR_H
+#ifndef CPYRT_CPPCONSTRUCTOR_H
+#define CPYRT_CPPCONSTRUCTOR_H
 
 // Bindings
 #include "CPPMethod.h"
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class CPPConstructor : public CPPMethod {
 public:
@@ -13,12 +13,12 @@ class CPPConstructor : public CPPMethod {
 
 public:
     PyObject* GetDocString() override;
-    PyObject* Reflex(Cppyy::Reflex::RequestId_t,
-                             Cppyy::Reflex::FormatId_t = Cppyy::Reflex::OPTIMAL) override;
+    PyObject* Reflex(cppjit::interop::Reflex::RequestId_t,
+                             cppjit::interop::Reflex::FormatId_t = cppjit::interop::Reflex::OPTIMAL) override;
 
     PyCallable* Clone() override { return new CPPConstructor(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 
 protected:
     bool InitExecutor_(Executor*&, CallContext* ctxt = nullptr) override;
@@ -28,14 +28,14 @@ class CPPConstructor : public CPPMethod {
 // specialization for multiple inheritance disambiguation
 class CPPMultiConstructor : public CPPConstructor {
 public:
-    CPPMultiConstructor(Cppyy::TCppScope_t scope, Cppyy::TCppMethod_t method);
+    CPPMultiConstructor(cppjit::interop::TCppScope_t scope, cppjit::interop::TCppMethod_t method);
     CPPMultiConstructor(const CPPMultiConstructor&);
     CPPMultiConstructor& operator=(const CPPMultiConstructor&);
 
 public:
     PyCallable* Clone() override { return new CPPMultiConstructor(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 
 private:
     Py_ssize_t fNumBases;
@@ -50,7 +50,7 @@ class CPPAbstractClassConstructor : public CPPConstructor {
 public:
     PyCallable* Clone() override { return new CPPAbstractClassConstructor(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 };
 
 class CPPNamespaceConstructor : public CPPConstructor {
@@ -60,7 +60,7 @@ class CPPNamespaceConstructor : public CPPConstructor {
 public:
     PyCallable* Clone() override { return new CPPNamespaceConstructor(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 };
 
 class CPPIncompleteClassConstructor : public CPPConstructor {
@@ -70,7 +70,7 @@ class CPPIncompleteClassConstructor : public CPPConstructor {
 public:
     PyCallable* Clone() override { return new CPPIncompleteClassConstructor(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 };
 
 class CPPAllPrivateClassConstructor : public CPPConstructor {
@@ -80,9 +80,9 @@ class CPPAllPrivateClassConstructor : public CPPConstructor {
 public:
     PyCallable* Clone() override { return new CPPAllPrivateClassConstructor(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPCONSTRUCTOR_H
+#endif // !CPYRT_CPPCONSTRUCTOR_H
diff --git a/src/CPyCppyy/src/CPPDataMember.cxx b/src/cpyrt/CPPDataMember.cxx
similarity index 76%
rename from src/CPyCppyy/src/CPPDataMember.cxx
rename to src/cpyrt/CPPDataMember.cxx
index ae2e742..959d89b 100644
--- a/src/CPyCppyy/src/CPPDataMember.cxx
+++ b/src/cpyrt/CPPDataMember.cxx
@@ -1,7 +1,7 @@
 // Bindings
-#include "CPyCppyy.h"
-#include "CPyCppyy/Reflex.h"
-#include "Cppyy.h"
+#include "cpyrt.h"
+#include "cpyrt/Reflex.h"
+#include "cppjit_interop.h"
 #include "PyStrings.h"
 #include "CPPDataMember.h"
 #include "CPPInstance.h"
@@ -19,7 +19,7 @@
 #include <limits.h>
 #include <structmember.h>
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 enum ETypeDetails {
     kNone          = 0x0000,
@@ -31,12 +31,12 @@ enum ETypeDetails {
     kIsCachable    = 0x0020
 };
 
-//= CPyCppyy data member as Python property behavior =========================
+//= cpyrt data member as Python property behavior =========================
 static PyObject* dm_get(CPPDataMember* dm, CPPInstance* pyobj, PyObject* /* kls */)
 {
 // cache lookup for low level views
     if (pyobj && dm->fFlags & kIsCachable) {
-        CPyCppyy::CI_DatamemberCache_t& cache = pyobj->GetDatamemberCache();
+        cppjit::cpyrt::CI_DatamemberCache_t& cache = pyobj->GetDatamemberCache();
         for (auto it = cache.begin(); it != cache.end(); ++it) {
             if (it->first == dm->fOffset) {
                 if (it->second) {
@@ -56,16 +56,16 @@ static PyObject* dm_get(CPPDataMember* dm, CPPInstance* pyobj, PyObject* /* kls
             dm->fFlags &= ~kIsEnumPrep;
 
         // fDescription contains the full name of the actual enum value object
-            const Cppyy::TCppScope_t enum_type  = Cppyy::GetParentScope(dm->fScope);
-            const Cppyy::TCppScope_t enum_scope = Cppyy::GetParentScope(enum_type);
+            const cppjit::interop::TCppScope_t enum_type  = cppjit::interop::GetParentScope(dm->fScope);
+            const cppjit::interop::TCppScope_t enum_scope = cppjit::interop::GetParentScope(enum_type);
 
             PyObject* pyscope = CreateScopeProxy(enum_scope);
             if (pyscope) {
                 PyObject* pyEnumType = 
-                    PyObject_GetAttrString(pyscope, Cppyy::GetFinalName(enum_type).c_str());
+                    PyObject_GetAttrString(pyscope, cppjit::interop::GetFinalName(enum_type).c_str());
                 if (pyEnumType) {
                     PyObject* pyval =
-                        PyObject_GetAttrString(pyEnumType, Cppyy::GetFinalName(dm->fScope).c_str());
+                        PyObject_GetAttrString(pyEnumType, cppjit::interop::GetFinalName(dm->fScope).c_str());
                     Py_DECREF(pyEnumType);
                     if (pyval) {
                         Py_DECREF(dm->fDescription);
@@ -84,9 +84,9 @@ static PyObject* dm_get(CPPDataMember* dm, CPPInstance* pyobj, PyObject* /* kls
             return dm->fDescription;
         }
 
-        if (Cppyy::IsEnumConstant(dm->fScope)) {
+        if (cppjit::interop::IsEnumConstant(dm->fScope)) {
             // anonymous enum
-            return pyval_from_enum(Cppyy::ResolveEnum(dm->fScope), nullptr, nullptr, dm->fScope);
+            return pyval_from_enum(cppjit::interop::ResolveEnum(dm->fScope), nullptr, nullptr, dm->fScope);
         }
     }
 // non-initialized or public data accesses through class (e.g. by help())
@@ -134,7 +134,7 @@ static int dm_set(CPPDataMember* dm, CPPInstance* pyobj, PyObject* value)
     if (!value) {
     // we're being deleted; fine for namespaces (redo lookup next time), but makes
     // no sense for classes/structs
-        if (!Cppyy::IsNamespace(dm->fEnclosingScope)) {
+        if (!cppjit::interop::IsNamespace(dm->fEnclosingScope)) {
             PyErr_SetString(PyExc_TypeError, "data member deletion is not supported");
             return errret;
         }
@@ -154,7 +154,7 @@ static int dm_set(CPPDataMember* dm, CPPInstance* pyobj, PyObject* value)
 
 // remove cached low level view, if any (will be restored upon reaeding)
     if (dm->fFlags & kIsCachable) {
-        CPyCppyy::CI_DatamemberCache_t& cache = pyobj->GetDatamemberCache();
+        cppjit::cpyrt::CI_DatamemberCache_t& cache = pyobj->GetDatamemberCache();
         for (auto it = cache.begin(); it != cache.end(); ++it) {
             if (it->first == dm->fOffset) {
                 Py_XDECREF(it->second);
@@ -185,7 +185,7 @@ static int dm_set(CPPDataMember* dm, CPPInstance* pyobj, PyObject* value)
     return errret;
 }
 
-//= CPyCppyy data member construction/destruction ===========================
+//= cpyrt data member construction/destruction ===========================
 static CPPDataMember* dm_new(PyTypeObject* pytype, PyObject*, PyObject*)
 {
 // Create and initialize a new property descriptor.
@@ -223,20 +223,20 @@ static PyMemberDef dm_members[] = {
         {NULL, 0, 0, 0, nullptr}  /* Sentinel */
 };
 
-//= CPyCppyy datamember proxy access to internals ============================
+//= cpyrt datamember proxy access to internals ============================
 static PyObject* dm_reflex(CPPDataMember* dm, PyObject* args)
 {
 // Provide the requested reflection information.
-    Cppyy::Reflex::RequestId_t request = -1;
-    Cppyy::Reflex::FormatId_t  format  = Cppyy::Reflex::OPTIMAL;
+    cppjit::interop::Reflex::RequestId_t request = -1;
+    cppjit::interop::Reflex::FormatId_t  format  = cppjit::interop::Reflex::OPTIMAL;
     if (!PyArg_ParseTuple(args, const_cast<char*>("i|i:__cpp_reflex__"), &request, &format))
         return nullptr;
 
-    if (request == Cppyy::Reflex::TYPE) {
-        if (format == Cppyy::Reflex::OPTIMAL || format == Cppyy::Reflex::AS_STRING)
-            return CPyCppyy_PyText_FromString(dm->fFullType.c_str());
-    } else if (request == Cppyy::Reflex::OFFSET) {
-        if (format == Cppyy::Reflex::OPTIMAL)
+    if (request == cppjit::interop::Reflex::TYPE) {
+        if (format == cppjit::interop::Reflex::OPTIMAL || format == cppjit::interop::Reflex::AS_STRING)
+            return cpyrt_PyText_FromString(dm->fFullType.c_str());
+    } else if (request == cppjit::interop::Reflex::OFFSET) {
+        if (format == cppjit::interop::Reflex::OPTIMAL)
             return PyLong_FromLong(dm->fOffset);
     }
 
@@ -252,10 +252,10 @@ static PyMethodDef dm_methods[] = {
 };
 
 
-//= CPyCppyy data member type ================================================
+//= cpyrt data member type ================================================
 PyTypeObject CPPDataMember_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.CPPDataMember",  // tp_name
+    (char*)"cppjit.CPPDataMember",  // tp_name
     sizeof(CPPDataMember),         // tp_basicsize
     0,                             // tp_itemsize
     (destructor)dm_dealloc,        // tp_dealloc
@@ -274,7 +274,7 @@ PyTypeObject CPPDataMember_Type = {
     0,                             // tp_setattro
     0,                             // tp_as_buffer
     Py_TPFLAGS_DEFAULT,            // tp_flags
-    (char*)"cppyy data member (internal)",       // tp_doc
+    (char*)"cppjit data member (internal)",       // tp_doc
     0,                             // tp_traverse
     0,                             // tp_clear
     0,                             // tp_richcompare
@@ -303,53 +303,53 @@ PyTypeObject CPPDataMember_Type = {
     0,                             // tp_version_tag
     0,                             // tp_finalize
     0                              // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 
 //- public members -----------------------------------------------------------
-void CPyCppyy::CPPDataMember::Set(Cppyy::TCppScope_t scope, Cppyy::TCppScope_t data)
+void cppjit::cpyrt::CPPDataMember::Set(cppjit::interop::TCppScope_t scope, cppjit::interop::TCppScope_t data)
 {
-    if (Cppyy::IsLambdaClass(Cppyy::GetDatamemberType(data))) {
-        fScope = Cppyy::WrapLambdaFromVariable(data);
+    if (cppjit::interop::IsLambdaClass(cppjit::interop::GetDatamemberType(data))) {
+        fScope = cppjit::interop::WrapLambdaFromVariable(data);
     } else {
         fScope = data;
     }
 
     fEnclosingScope = scope;
-    fOffset         = Cppyy::GetDatamemberOffset(fScope, fScope == data ? scope : Cppyy::GetScope("__cppyy_internal_wrap_g")); // XXX: Check back here // TODO: make lazy
-    fFlags          = Cppyy::IsStaticDatamember(fScope) ? kIsStaticData : 0;
+    fOffset         = cppjit::interop::GetDatamemberOffset(fScope, fScope == data ? scope : cppjit::interop::GetScope("__cppjit_internal_wrap_g")); // XXX: Check back here // TODO: make lazy
+    fFlags          = cppjit::interop::IsStaticDatamember(fScope) ? kIsStaticData : 0;
 
-    const std::string name = Cppyy::GetFinalName(fScope);
-    Cppyy::TCppType_t type;
+    const std::string name = cppjit::interop::GetFinalName(fScope);
+    cppjit::interop::TCppType_t type;
 
 
-    if (Cppyy::IsEnumConstant(fScope)) {
-        type = Cppyy::GetEnumConstantType(fScope);
-        fFullType = Cppyy::GetTypeAsString(type);
+    if (cppjit::interop::IsEnumConstant(fScope)) {
+        type = cppjit::interop::GetEnumConstantType(fScope);
+        fFullType = cppjit::interop::GetTypeAsString(type);
         if (fFullType.find("(anonymous)") == std::string::npos &&
             fFullType.find("(unnamed)")   == std::string::npos) {
         // repurpose fDescription for lazy lookup of the enum later
-            fDescription = CPyCppyy_PyText_FromString((fFullType + "::" + name).c_str());
+            fDescription = cpyrt_PyText_FromString((fFullType + "::" + name).c_str());
             fFlags |= kIsEnumPrep;
         }
-        type = Cppyy::ResolveType(type);
+        type = cppjit::interop::ResolveType(type);
         fFlags |= kIsConstData;
     } else {
-        type = Cppyy::GetDatamemberType(fScope);
-        fFullType = Cppyy::GetTypeAsString(type);
+        type = cppjit::interop::GetDatamemberType(fScope);
+        fFullType = cppjit::interop::GetTypeAsString(type);
 
         // Get the integer type if it's an enum
-        if (Cppyy::IsEnumType(type))
-            type = Cppyy::ResolveType(type);
+        if (cppjit::interop::IsEnumType(type))
+            type = cppjit::interop::ResolveType(type);
         
-        if (Cppyy::IsConstVar(fScope))
+        if (cppjit::interop::IsConstVar(fScope))
             fFlags |= kIsConstData;
     }
 
-    auto ldims = Cppyy::GetDimensions(type);
+    auto ldims = cppjit::interop::GetDimensions(type);
     std::vector<dim_t> dims(ldims.begin(), ldims.end());
 
     if (!dims.empty())
@@ -361,14 +361,14 @@ void CPyCppyy::CPPDataMember::Set(Cppyy::TCppScope_t scope, Cppyy::TCppScope_t d
         fConverter = CreateConverter(type, {(dim_t)dims.size(), dims.data()});
 
     if (!(fFlags & kIsEnumPrep))
-        fDescription = CPyCppyy_PyText_FromString(name.c_str());
+        fDescription = cpyrt_PyText_FromString(name.c_str());
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::CPPDataMember::Set(Cppyy::TCppScope_t scope, const std::string& name, void* address)
+void cppjit::cpyrt::CPPDataMember::Set(cppjit::interop::TCppScope_t scope, const std::string& name, void* address)
 {
     fEnclosingScope = scope;
-    fDescription    = CPyCppyy_PyText_FromString(name.c_str());
+    fDescription    = cpyrt_PyText_FromString(name.c_str());
     fOffset         = (intptr_t)address;
     fFlags          = kIsStaticData | kIsConstData;
     fConverter      = CreateConverter("internal_enum_type_t");
@@ -377,7 +377,7 @@ void CPyCppyy::CPPDataMember::Set(Cppyy::TCppScope_t scope, const std::string& n
 
 
 //-----------------------------------------------------------------------------
-void* CPyCppyy::CPPDataMember::GetAddress(CPPInstance* pyobj)
+void* cppjit::cpyrt::CPPDataMember::GetAddress(CPPInstance* pyobj)
 {
 // class attributes, global properties
     if (fFlags & kIsStaticData)
@@ -404,30 +404,30 @@ void* CPyCppyy::CPPDataMember::GetAddress(CPPInstance* pyobj)
 
 // the proxy's internal offset is calculated from the enclosing class
     ptrdiff_t offset = 0;
-    Cppyy::TCppScope_t oisa = pyobj->ObjectIsA();
+    cppjit::interop::TCppScope_t oisa = pyobj->ObjectIsA();
     if (oisa != fEnclosingScope)
-        offset = Cppyy::GetBaseOffset(oisa, fEnclosingScope, obj, 1 /* up-cast */);
+        offset = cppjit::interop::GetBaseOffset(oisa, fEnclosingScope, obj, 1 /* up-cast */);
 
     return (void*)((intptr_t)obj + offset + fOffset);
 }
 
 
 //-----------------------------------------------------------------------------
-std::string CPyCppyy::CPPDataMember::GetName()
+std::string cppjit::cpyrt::CPPDataMember::GetName()
 {
     if (fFlags & kIsEnumType) {
         PyObject* repr = PyObject_Repr(fDescription);
         if (repr) {
-            std::string res = CPyCppyy_PyText_AsString(repr);
+            std::string res = cpyrt_PyText_AsString(repr);
             Py_DECREF(repr);
             return res;
         }
         PyErr_Clear();
         return "<unknown>";
     } else if (fFlags & kIsEnumPrep) {
-        std::string fullName = CPyCppyy_PyText_AsString(fDescription);
+        std::string fullName = cpyrt_PyText_AsString(fDescription);
         return fullName.substr(fullName.rfind("::")+2, std::string::npos);
     }
 
-    return CPyCppyy_PyText_AsString(fDescription);
+    return cpyrt_PyText_AsString(fDescription);
 }
diff --git a/src/CPyCppyy/src/CPPDataMember.h b/src/cpyrt/CPPDataMember.h
similarity index 76%
rename from src/CPyCppyy/src/CPPDataMember.h
rename to src/cpyrt/CPPDataMember.h
index 9241b4d..d0a69e4 100644
--- a/src/CPyCppyy/src/CPPDataMember.h
+++ b/src/cpyrt/CPPDataMember.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_CPPDATAMEMBER_H
-#define CPYCPPYY_CPPDATAMEMBER_H
+#ifndef CPYRT_CPPDATAMEMBER_H
+#define CPYRT_CPPDATAMEMBER_H
 
 // Bindings
 #include "Converters.h"
@@ -8,14 +8,14 @@
 #include <string>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class CPPInstance;
 
 class CPPDataMember {
 public:
-    void Set(Cppyy::TCppScope_t scope, Cppyy::TCppScope_t var);
-    void Set(Cppyy::TCppScope_t scope, const std::string& name, void* address);
+    void Set(cppjit::interop::TCppScope_t scope, cppjit::interop::TCppScope_t var);
+    void Set(cppjit::interop::TCppScope_t scope, const std::string& name, void* address);
 
     std::string GetName();
     void* GetAddress(CPPInstance* pyobj /* owner */);
@@ -25,8 +25,8 @@ class CPPDataMember {
     intptr_t           fOffset;
     long               fFlags;
     Converter*         fConverter;
-    Cppyy::TCppScope_t fScope;
-    Cppyy::TCppScope_t fEnclosingScope;
+    cppjit::interop::TCppScope_t fScope;
+    cppjit::interop::TCppScope_t fEnclosingScope;
     PyObject*          fDescription;
     PyObject*          fDoc;
 
@@ -56,7 +56,7 @@ inline bool CPPDataMember_CheckExact(T* object)
 
 //- creation -----------------------------------------------------------------
 inline CPPDataMember* CPPDataMember_New(
-    Cppyy::TCppScope_t scope, Cppyy::TCppScope_t var)
+    cppjit::interop::TCppScope_t scope, cppjit::interop::TCppScope_t var)
 {
 // Create an initialize a new property descriptor, given the C++ datum.
     CPPDataMember* pyprop =
@@ -66,7 +66,7 @@ inline CPPDataMember* CPPDataMember_New(
 }
 
 inline CPPDataMember* CPPDataMember_NewConstant(
-    Cppyy::TCppScope_t scope, const std::string& name, void* address)
+    cppjit::interop::TCppScope_t scope, const std::string& name, void* address)
 {
 // Create an initialize a new property descriptor, given the C++ datum.
     CPPDataMember* pyprop =
@@ -75,6 +75,6 @@ inline CPPDataMember* CPPDataMember_NewConstant(
     return pyprop;
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPDATAMEMBER_H
+#endif // !CPYRT_CPPDATAMEMBER_H
diff --git a/src/CPyCppyy/src/CPPEnum.cxx b/src/cpyrt/CPPEnum.cxx
similarity index 81%
rename from src/CPyCppyy/src/CPPEnum.cxx
rename to src/cpyrt/CPPEnum.cxx
index 3012442..d51d22d 100644
--- a/src/CPyCppyy/src/CPPEnum.cxx
+++ b/src/cpyrt/CPPEnum.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPEnum.h"
 #include "PyStrings.h"
 #include "TypeManip.h"
@@ -11,7 +11,7 @@
 static PyObject* pytype_from_enum_type(const std::string& enum_type)
 {
     if (enum_type == "char")
-        return (PyObject*)&CPyCppyy_PyText_Type;
+        return (PyObject*)&cpyrt_PyText_Type;
     else if (enum_type == "bool")
         return (PyObject*)&PyInt_Type;     // can't use PyBool_Type as base
     else if (strstr("long", enum_type.c_str()))
@@ -20,9 +20,9 @@ static PyObject* pytype_from_enum_type(const std::string& enum_type)
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::pyval_from_enum(const std::string& enum_type, PyObject* pytype,
-        PyObject* btype, Cppyy::TCppScope_t enum_constant) {
-    long long llval = Cppyy::GetEnumDataValue(enum_constant);
+PyObject* cppjit::cpyrt::pyval_from_enum(const std::string& enum_type, PyObject* pytype,
+        PyObject* btype, cppjit::interop::TCppScope_t enum_constant) {
+    long long llval = cppjit::interop::GetEnumDataValue(enum_constant);
 
     if (enum_type == "bool" && !(pytype && btype)) {
     // no enum class to instantiate; the singletons can not carry attributes
@@ -63,7 +63,7 @@ static int enum_setattro(PyObject* /* pyclass */, PyObject* /* pyname */, PyObje
 //----------------------------------------------------------------------------
 static PyObject* enum_repr(PyObject* self)
 {
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
 
     PyObject* kls_scope = PyObject_GetAttr((PyObject*)Py_TYPE(self), PyStrings::gThisModule);
     if (!kls_scope) PyErr_Clear();
@@ -75,10 +75,10 @@ static PyObject* enum_repr(PyObject* self)
 
     PyObject* repr = nullptr;
     if (kls_cppname && obj_cppname && obj_str) {
-        const std::string resolved = Cppyy::ResolveEnum(PyLong_AsVoidPtr(kls_scope));
-        repr = CPyCppyy_PyText_FromFormat("(%s::%s) : (%s) %s",
-            CPyCppyy_PyText_AsString(kls_cppname), CPyCppyy_PyText_AsString(obj_cppname),
-            resolved.c_str(), CPyCppyy_PyText_AsString(obj_str));
+        const std::string resolved = cppjit::interop::ResolveEnum(PyLong_AsVoidPtr(kls_scope));
+        repr = cpyrt_PyText_FromFormat("(%s::%s) : (%s) %s",
+            cpyrt_PyText_AsString(kls_cppname), cpyrt_PyText_AsString(obj_cppname),
+            resolved.c_str(), cpyrt_PyText_AsString(obj_str));
     }
     Py_XDECREF(obj_cppname);
     Py_XDECREF(kls_cppname);
@@ -125,10 +125,10 @@ static PyTypeObject* GetCTypesType(const std::string& cppname)
 
 static PyObject* enum_ctype(PyObject* cls, PyObject* args, PyObject* kwds)
 {
-    PyObject* pyres = PyObject_GetAttr(cls, CPyCppyy::PyStrings::gUnderlying);
+    PyObject* pyres = PyObject_GetAttr(cls, cppjit::cpyrt::PyStrings::gUnderlying);
     if (!pyres) PyErr_Clear();
 
-    std::string underlying = pyres ? CPyCppyy_PyText_AsString(pyres) : "int";
+    std::string underlying = pyres ? cpyrt_PyText_AsString(pyres) : "int";
     PyTypeObject* ct = GetCTypesType(underlying);
     if (!ct)
         return nullptr;
@@ -138,19 +138,19 @@ static PyObject* enum_ctype(PyObject* cls, PyObject* args, PyObject* kwds)
 
 
 //- creation -----------------------------------------------------------------
-CPyCppyy::CPPEnum* CPyCppyy::CPPEnum_New(const std::string& name, Cppyy::TCppScope_t scope)
+cppjit::cpyrt::CPPEnum* cppjit::cpyrt::CPPEnum_New(const std::string& name, cppjit::interop::TCppScope_t scope)
 {
 // Create a new enum type based on the actual C++ type. Enum values are added to
 // the type but may also live in the enclosing scope.
 
     CPPEnum* pyenum = nullptr;
 
-    Cppyy::TCppScope_t etype = scope;
-    const std::string& ename = Cppyy::GetScopedFinalName(scope);
+    cppjit::interop::TCppScope_t etype = scope;
+    const std::string& ename = cppjit::interop::GetScopedFinalName(scope);
     if (etype) {
     // create new enum type with labeled values in place, with a meta-class
     // to make sure the enum values are read-only
-        const std::string& resolved = Cppyy::ResolveEnum(etype);
+        const std::string& resolved = cppjit::interop::ResolveEnum(etype);
         PyObject* pyside_type = pytype_from_enum_type(resolved);
         PyObject* pymetabases = PyTuple_New(1);
         PyObject* btype = (PyObject*)Py_TYPE(pyside_type);
@@ -169,12 +169,12 @@ CPyCppyy::CPPEnum* CPyCppyy::CPPEnum_New(const std::string& name, Cppyy::TCppSco
 
     // create the __cpp_name__ for templates
         PyObject* dct = PyDict_New();
-        PyObject* pycppname = CPyCppyy_PyText_FromString(ename.c_str());
+        PyObject* pycppname = cpyrt_PyText_FromString(ename.c_str());
         PyObject* pycppscope = PyLong_FromVoidPtr(etype.data);
         PyDict_SetItem(dct, PyStrings::gCppName, pycppname);
         PyDict_SetItem(dct, PyStrings::gThisModule, pycppscope);
         Py_DECREF(pycppname);
-        PyObject* pyresolved = CPyCppyy_PyText_FromString(resolved.c_str());
+        PyObject* pyresolved = cpyrt_PyText_FromString(resolved.c_str());
         PyDict_SetItem(dct, PyStrings::gUnderlying, pyresolved);
         Py_DECREF(pyresolved);
     
@@ -182,7 +182,7 @@ CPyCppyy::CPPEnum* CPyCppyy::CPPEnum_New(const std::string& name, Cppyy::TCppSco
         std::string modname = TypeManip::extract_namespace(ename);
         TypeManip::cppscope_to_pyscope(modname);      // :: -> .
         if (!modname.empty()) modname = "."+modname;
-        PyObject* pymodname = CPyCppyy_PyText_FromString(("cppyy.gbl"+modname).c_str());
+        PyObject* pymodname = cpyrt_PyText_FromString(("cppjit.gbl"+modname).c_str());
         PyDict_SetItem(dct, PyStrings::gModule, pymodname);
         Py_DECREF(pymodname);
 
@@ -199,7 +199,7 @@ CPyCppyy::CPPEnum* CPyCppyy::CPPEnum_New(const std::string& name, Cppyy::TCppSco
         ((PyTypeObject*)pyenum)->tp_str  = ((PyTypeObject*)pyside_type)->tp_repr;
 
     // collect the enum values
-        std::vector<Cppyy::TCppScope_t> econstants = Cppyy::GetEnumConstants(etype);
+        std::vector<cppjit::interop::TCppScope_t> econstants = cppjit::interop::GetEnumConstants(etype);
         bool values_ok = true;
         for (auto econstant : econstants) {
             PyObject* val = pyval_from_enum(resolved, pyenum, pyside_type, econstant);
@@ -207,11 +207,11 @@ CPyCppyy::CPPEnum* CPyCppyy::CPPEnum_New(const std::string& name, Cppyy::TCppSco
                 values_ok = false;
                 break;
             }
-            const std::string& dname = Cppyy::GetFinalName(econstant);
-            PyObject* pydname = CPyCppyy_PyText_FromString(dname.c_str());
+            const std::string& dname = cppjit::interop::GetFinalName(econstant);
+            PyObject* pydname = cpyrt_PyText_FromString(dname.c_str());
             PyObject_SetAttr(pyenum, pydname, val);
             Py_DECREF(pydname);
-            PyObject* pydcppname = CPyCppyy_PyText_FromString((ename.empty() ? dname : (ename+"::"+dname)).c_str());
+            PyObject* pydcppname = cpyrt_PyText_FromString((ename.empty() ? dname : (ename+"::"+dname)).c_str());
             PyObject_SetAttr(val, PyStrings::gCppName, pydcppname);
             Py_DECREF(pydcppname);
             Py_DECREF(val);
diff --git a/src/CPyCppyy/src/CPPEnum.h b/src/cpyrt/CPPEnum.h
similarity index 54%
rename from src/CPyCppyy/src/CPPEnum.h
rename to src/cpyrt/CPPEnum.h
index d1d0e9e..d064daf 100644
--- a/src/CPyCppyy/src/CPPEnum.h
+++ b/src/cpyrt/CPPEnum.h
@@ -1,18 +1,18 @@
-#ifndef CPYCPPYY_CPPENUM_H
-#define CPYCPPYY_CPPENUM_H
+#ifndef CPYRT_CPPENUM_H
+#define CPYRT_CPPENUM_H
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 // CPPEnum does not carry any additional C-side data for now, but can be of
 // several types, based on the declared or compile-dependent types chosen.
 typedef PyObject CPPEnum;
 
 //- creation -----------------------------------------------------------------
-CPPEnum* CPPEnum_New(const std::string& name, Cppyy::TCppScope_t scope);
+CPPEnum* CPPEnum_New(const std::string& name, cppjit::interop::TCppScope_t scope);
 
 PyObject* pyval_from_enum(const std::string& enum_type, PyObject* pytype,
-        PyObject* btype, Cppyy::TCppScope_t enum_constant);
-} // namespace CPyCppyy
+        PyObject* btype, cppjit::interop::TCppScope_t enum_constant);
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPENUM_H
+#endif // !CPYRT_CPPENUM_H
diff --git a/src/CPyCppyy/src/CPPExcInstance.cxx b/src/cpyrt/CPPExcInstance.cxx
similarity index 95%
rename from src/CPyCppyy/src/CPPExcInstance.cxx
rename to src/cpyrt/CPPExcInstance.cxx
index 07270fd..b78c98e 100644
--- a/src/CPyCppyy/src/CPPExcInstance.cxx
+++ b/src/cpyrt/CPPExcInstance.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPExcInstance.h"
 #include "PyStrings.h"
 
@@ -13,9 +13,9 @@
 // not carry that overhead. In use, it forwards to the embedded CPPInstance.
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
-//= CPyCppyy exception object proxy construction/destruction =================
+//= cpyrt exception object proxy construction/destruction =================
 static PyObject* ep_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
 {
 // Create a new exception object proxy (holder only).
@@ -34,7 +34,7 @@ static PyObject* ep_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
             PyErr_Clear();
             if (PyTuple_GET_SIZE(args) == 1) {
                 PyObject* msg = PyTuple_GET_ITEM(args, 0);
-                if (CPyCppyy_PyText_Check(msg)) {
+                if (cpyrt_PyText_Check(msg)) {
                     Py_INCREF(msg);
                     excobj->fTopMessage = msg;
                 }
@@ -71,7 +71,7 @@ static PyObject* ep_str(CPPExcInstance* self)
             if (self->fTopMessage) {
                 Py_INCREF(self->fTopMessage);
                 PyObject* top = self->fTopMessage;
-                CPyCppyy_PyText_Append(&top, what);
+                cpyrt_PyText_Append(&top, what);
                 Py_DECREF(what);
                 what = top;
             }
@@ -199,10 +199,10 @@ static PyNumberMethods ep_as_number = {
     0                              // nb_inplace_matrix_multiply
 };
 
-//= CPyCppyy exception object proxy type ======================================
+//= cpyrt exception object proxy type ======================================
 PyTypeObject CPPExcInstance_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.CPPExcInstance", // tp_name
+    (char*)"cppjit.CPPExcInstance", // tp_name
     sizeof(CPPExcInstance),        // tp_basicsize
     0,                             // tp_itemsize
     (destructor)ep_dealloc,        // tp_dealloc
@@ -225,7 +225,7 @@ PyTypeObject CPPExcInstance_Type = {
         Py_TPFLAGS_BASE_EXC_SUBCLASS |
         Py_TPFLAGS_HAVE_GC |
         Py_TPFLAGS_CHECKTYPES,     // tp_flags
-    (char*)"cppyy exception object proxy (internal)", // tp_doc
+    (char*)"cppjit exception object proxy (internal)", // tp_doc
     (traverseproc)ep_traverse,     // tp_traverse
     (inquiry)ep_clear,             // tp_clear
     (richcmpfunc)ep_richcompare,   // tp_richcompare
@@ -254,7 +254,7 @@ PyTypeObject CPPExcInstance_Type = {
     0,                             // tp_version_tag
     0,                             // tp_finalize
     0                              // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
diff --git a/src/CPyCppyy/src/CPPExcInstance.h b/src/cpyrt/CPPExcInstance.h
similarity index 77%
rename from src/CPyCppyy/src/CPPExcInstance.h
rename to src/cpyrt/CPPExcInstance.h
index 8dd7175..6d0ee38 100644
--- a/src/CPyCppyy/src/CPPExcInstance.h
+++ b/src/cpyrt/CPPExcInstance.h
@@ -1,15 +1,15 @@
-#ifndef CPYCPPYY_CPPEXCINSTANCE_H
-#define CPYCPPYY_CPPEXCINSTANCE_H
+#ifndef CPYRT_CPPEXCINSTANCE_H
+#define CPYRT_CPPEXCINSTANCE_H
 
 //////////////////////////////////////////////////////////////////////////////
 //                                                                          //
-// CpyCppyy::CPPExceptionInstance                                           //
+// Cpycppjit::interop::CPPExceptionInstance                                           //
 //                                                                          //
 // Python-side proxy, encapsulaties a C++ exception object.                 //
 //                                                                          //
 //////////////////////////////////////////////////////////////////////////////
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class CPPExcInstance {
 public:
@@ -20,7 +20,7 @@ class CPPExcInstance {
 
 
 //- object proxy type and type verification ----------------------------------
-CPYCPPYY_IMPORT PyTypeObject CPPExcInstance_Type;
+CPYRT_IMPORT PyTypeObject CPPExcInstance_Type;
 
 template<typename T>
 inline bool CPPExcInstance_Check(T* object)
@@ -34,6 +34,6 @@ inline bool CPPExcInstance_CheckExact(T* object)
     return object && Py_TYPE(object) == &CPPExcInstance_Type;
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPEXCINSTANCE_H
+#endif // !CPYRT_CPPEXCINSTANCE_H
diff --git a/src/CPyCppyy/src/CPPFunction.cxx b/src/cpyrt/CPPFunction.cxx
similarity index 81%
rename from src/CPyCppyy/src/CPPFunction.cxx
rename to src/cpyrt/CPPFunction.cxx
index 5cd8956..f9e4fe6 100644
--- a/src/CPyCppyy/src/CPPFunction.cxx
+++ b/src/cpyrt/CPPFunction.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPFunction.h"
 #include "CPPInstance.h"
 
@@ -8,7 +8,7 @@
 
 
 //- CFunction helpers -----------------------------------------------------------
-bool CPyCppyy::AdjustSelf(PyCallArgs& cargs)
+bool cppjit::cpyrt::AdjustSelf(PyCallArgs& cargs)
 {
     if (cargs.fNArgsf & PY_VECTORCALL_ARGUMENTS_OFFSET) {  // mutation allowed?
         std::swap(((PyObject**)cargs.fArgs-1)[0], (PyObject*&)cargs.fSelf);
@@ -33,7 +33,7 @@ bool CPyCppyy::AdjustSelf(PyCallArgs& cargs)
     return true;
 }
 
-bool CPyCppyy::CPPFunction::ProcessArgs(PyCallArgs& cargs)
+bool cppjit::cpyrt::CPPFunction::ProcessArgs(PyCallArgs& cargs)
 {
 // add self as part of the function arguments (means bound member)
     if (cargs.fKwds)
@@ -42,8 +42,8 @@ bool CPyCppyy::CPPFunction::ProcessArgs(PyCallArgs& cargs)
 }
 
 //- CPPFunction public members --------------------------------------------------
-PyObject* CPyCppyy::CPPFunction::Call(CPPInstance*& self,
-    CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CPPFunction::Call(CPPInstance*& self,
+    cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
 {
 // setup as necessary
     if (fArgsRequired == -1 && !this->Initialize(ctxt))
@@ -60,7 +60,7 @@ PyObject* CPyCppyy::CPPFunction::Call(CPPInstance*& self,
 // special case, if this method was inserted as a constructor, then self is nullptr
 // and it will be the first argument and needs to be used as Python context
     if (IsConstructor(ctxt->fFlags) && !ctxt->fPyContext && \
-            CPyCppyy_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf)) {
+            cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf)) {
         ctxt->fPyContext = cargs.fArgs[0];
     }
 
@@ -74,7 +74,7 @@ PyObject* CPyCppyy::CPPFunction::Call(CPPInstance*& self,
 // special case, if this method was inserted as a constructor, then if no self was
 // provided, it will be the first argument and may have been updated
     if (IsConstructor(ctxt->fFlags) && result && !cargs.fSelf && \
-            CPyCppyy_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf) && CPPInstance_Check(cargs.fArgs[0])) {
+            cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf) && CPPInstance_Check(cargs.fArgs[0])) {
         self = (CPPInstance*)cargs.fArgs[0];
         Py_INCREF(self);
     }
@@ -83,16 +83,16 @@ PyObject* CPyCppyy::CPPFunction::Call(CPPInstance*& self,
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPFunction::GetTypeName()
+PyObject* cppjit::cpyrt::CPPFunction::GetTypeName()
 {
-    PyObject* cppname = CPyCppyy_PyText_FromString((GetReturnTypeName() + " (*)").c_str());
-    CPyCppyy_PyText_AppendAndDel(&cppname, GetSignature(false /* show_formalargs */));
+    PyObject* cppname = cpyrt_PyText_FromString((GetReturnTypeName() + " (*)").c_str());
+    cpyrt_PyText_AppendAndDel(&cppname, GetSignature(false /* show_formalargs */));
     return cppname;
 }
 
 
 //- CPPReverseBinary private helper ---------------------------------------------
-bool CPyCppyy::CPPReverseBinary::ProcessArgs(PyCallArgs& cargs)
+bool cppjit::cpyrt::CPPReverseBinary::ProcessArgs(PyCallArgs& cargs)
 {
     if (cargs.fSelf || cargs.fKwds) {
     // add self as part of the function arguments (means bound member)
@@ -108,8 +108,8 @@ bool CPyCppyy::CPPReverseBinary::ProcessArgs(PyCallArgs& cargs)
 }
 
 //- CPPReverseBinary public members ---------------------------------------------
-PyObject* CPyCppyy::CPPReverseBinary::Call(CPPInstance*& self,
-    CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CPPReverseBinary::Call(CPPInstance*& self,
+    cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
 {
 // This Call() function is very similar to the one of CPPFunction: only difference is
 // that ProcessArgs() is always called.
diff --git a/src/CPyCppyy/src/CPPFunction.h b/src/cpyrt/CPPFunction.h
similarity index 70%
rename from src/CPyCppyy/src/CPPFunction.h
rename to src/cpyrt/CPPFunction.h
index f126f19..5d7bde8 100644
--- a/src/CPyCppyy/src/CPPFunction.h
+++ b/src/cpyrt/CPPFunction.h
@@ -1,11 +1,11 @@
-#ifndef CPYCPPYY_CPPFUNCTION_H
-#define CPYCPPYY_CPPFUNCTION_H
+#ifndef CPYRT_CPPFUNCTION_H
+#define CPYRT_CPPFUNCTION_H
 
 // Bindings
 #include "CPPMethod.h"
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 // Wrapper for global free/static C++ functions
 class CPPFunction : public CPPMethod {
@@ -18,7 +18,7 @@ class CPPFunction : public CPPMethod {
 public:
     PyCallable* Clone() override { return new CPPFunction(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 
 protected:
     bool ProcessArgs(PyCallArgs& args) override;
@@ -31,7 +31,7 @@ class CPPReverseBinary : public CPPFunction {
 
     PyCallable* Clone() override { return new CPPFunction(*this); }
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 
 protected:
     bool ProcessArgs(PyCallArgs& args) override;
@@ -40,6 +40,6 @@ class CPPReverseBinary : public CPPFunction {
 // Helper to add self to the arguments tuple if rebound
 bool AdjustSelf(PyCallArgs& cargs);
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPFUNCTION_H
+#endif // !CPYRT_CPPFUNCTION_H
diff --git a/src/CPyCppyy/src/CPPGetSetItem.cxx b/src/cpyrt/CPPGetSetItem.cxx
similarity index 72%
rename from src/CPyCppyy/src/CPPGetSetItem.cxx
rename to src/cpyrt/CPPGetSetItem.cxx
index 5f4eff1..a5ff620 100644
--- a/src/CPyCppyy/src/CPPGetSetItem.cxx
+++ b/src/cpyrt/CPPGetSetItem.cxx
@@ -1,31 +1,31 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPGetSetItem.h"
 #include "Executors.h"
 
 
 //- private helpers -----------------------------------------------------------
 static inline
-void unroll(CPyCppyy_PyArgs_t packed_args, CPyCppyy_PyArgs_t unrolled, Py_ssize_t nArgs)
+void unroll(cpyrt_PyArgs_t packed_args, cpyrt_PyArgs_t unrolled, Py_ssize_t nArgs)
 {
 // Unroll up to nArgs arguments from packed_args into unrolled.
     for (int i = 0, iur = 0; i < nArgs; ++i, ++iur) {
-        PyObject* item = CPyCppyy_PyArgs_GET_ITEM(packed_args, i);
+        PyObject* item = cpyrt_PyArgs_GET_ITEM(packed_args, i);
         if (PyTuple_Check(item)) {
             for (int j = 0; j < PyTuple_GET_SIZE(item); ++j, ++iur) {
                 PyObject* subitem = PyTuple_GET_ITEM(item, j);
                 Py_INCREF(subitem);
-                CPyCppyy_PyArgs_SET_ITEM(unrolled, iur, subitem);
+                cpyrt_PyArgs_SET_ITEM(unrolled, iur, subitem);
             }
         } else {
             Py_INCREF(item);
-            CPyCppyy_PyArgs_SET_ITEM(unrolled, iur, item);
+            cpyrt_PyArgs_SET_ITEM(unrolled, iur, item);
         }
     }
 }
 
 //- protected members ---------------------------------------------------------
-bool CPyCppyy::CPPSetItem::InitExecutor_(Executor*& executor, CallContext*)
+bool cppjit::cpyrt::CPPSetItem::InitExecutor_(Executor*& executor, CallContext*)
 {
 // basic call will do
     if (!CPPMethod::InitExecutor_(executor))
@@ -43,10 +43,10 @@ bool CPyCppyy::CPPSetItem::InitExecutor_(Executor*& executor, CallContext*)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::CPPSetItem::ProcessArgs(PyCallArgs& cargs)
+bool cppjit::cpyrt::CPPSetItem::ProcessArgs(PyCallArgs& cargs)
 {
 // Prepare executor with a buffer for the return value.
-    Py_ssize_t nArgs = CPyCppyy_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
+    Py_ssize_t nArgs = cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
     if (nArgs <= 1) {
         PyErr_SetString(PyExc_TypeError, "insufficient arguments to __setitem__");
         return false;
@@ -54,18 +54,18 @@ bool CPyCppyy::CPPSetItem::ProcessArgs(PyCallArgs& cargs)
 
 // use the last element of args for assignment upon return, then slice it from
 // the (unrolled) actual arguments
-    ((RefExecutor*)this->GetExecutor())->SetAssignable(CPyCppyy_PyArgs_GET_ITEM(cargs.fArgs, nArgs-1));
+    ((RefExecutor*)this->GetExecutor())->SetAssignable(cpyrt_PyArgs_GET_ITEM(cargs.fArgs, nArgs-1));
 
 // see whether any of the arguments is a tuple to be unrolled
     Py_ssize_t realsize = 0;
     for (Py_ssize_t i = 0; i < nArgs-1; ++i) {
-        PyObject* item = CPyCppyy_PyArgs_GET_ITEM(cargs.fArgs, i);
+        PyObject* item = cpyrt_PyArgs_GET_ITEM(cargs.fArgs, i);
         realsize += PyTuple_Check(item) ? PyTuple_GET_SIZE(item) : 1;
     }
 
 // unroll any tuples, if present in the arguments
     if (realsize != nArgs-1) {
-        CPyCppyy_PyArgs_t unrolled = (PyObject**)PyMem_Malloc(realsize * sizeof(PyObject*));
+        cpyrt_PyArgs_t unrolled = (PyObject**)PyMem_Malloc(realsize * sizeof(PyObject*));
         unroll(cargs.fArgs, unrolled, nArgs-1);
         cargs.fArgs = unrolled;
         cargs.fFlags |= PyCallArgs::kDoFree;
@@ -78,21 +78,21 @@ bool CPyCppyy::CPPSetItem::ProcessArgs(PyCallArgs& cargs)
 
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::CPPGetItem::ProcessArgs(PyCallArgs& cargs)
+bool cppjit::cpyrt::CPPGetItem::ProcessArgs(PyCallArgs& cargs)
 {
 // Unroll tuples for call, otherwise just like regular CPPMethod of __getitem__.
-    Py_ssize_t nArgs = CPyCppyy_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
+    Py_ssize_t nArgs = cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
 
 // see whether any of the arguments is a tuple to be unrolled
     Py_ssize_t realsize = 0;
     for (Py_ssize_t i = 0; i < nArgs; ++i) {
-        PyObject* item = CPyCppyy_PyArgs_GET_ITEM(cargs.fArgs, i);
+        PyObject* item = cpyrt_PyArgs_GET_ITEM(cargs.fArgs, i);
         realsize += PyTuple_Check(item) ? PyTuple_GET_SIZE(item) : 1;
     }
 
 // unroll any tuples, if present in the arguments
     if (realsize != nArgs) {
-        CPyCppyy_PyArgs_t packed_args = cargs.fArgs;
+        cpyrt_PyArgs_t packed_args = cargs.fArgs;
         cargs.fArgs = (PyObject**)PyMem_Malloc(realsize * sizeof(PyObject*));
         cargs.fFlags |= PyCallArgs::kDoFree;
         cargs.fNArgsf = realsize;
diff --git a/src/CPyCppyy/src/CPPGetSetItem.h b/src/cpyrt/CPPGetSetItem.h
similarity index 78%
rename from src/CPyCppyy/src/CPPGetSetItem.h
rename to src/cpyrt/CPPGetSetItem.h
index 3b6f42e..8af1930 100644
--- a/src/CPyCppyy/src/CPPGetSetItem.h
+++ b/src/cpyrt/CPPGetSetItem.h
@@ -1,11 +1,11 @@
-#ifndef CPYCPPYY_CPPGETSETITEM_H
-#define CPYCPPYY_CPPGETSETITEM_H
+#ifndef CPYRT_CPPGETSETITEM_H
+#define CPYRT_CPPGETSETITEM_H
 
 // Bindings
 #include "CPPMethod.h"
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class CPPSetItem : public CPPMethod {
 public:
@@ -30,6 +30,6 @@ class CPPGetItem : public CPPMethod {
     bool ProcessArgs(PyCallArgs& args) override;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPGETSETITEM_H
+#endif // !CPYRT_CPPGETSETITEM_H
diff --git a/src/CPyCppyy/src/CPPInstance.cxx b/src/cpyrt/CPPInstance.cxx
similarity index 87%
rename from src/CPyCppyy/src/CPPInstance.cxx
rename to src/cpyrt/CPPInstance.cxx
index a7f0141..46e9fd3 100644
--- a/src/CPyCppyy/src/CPPInstance.cxx
+++ b/src/cpyrt/CPPInstance.cxx
@@ -1,16 +1,16 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPInstance.h"
 #include "CPPScope.h"
 #include "CPPOverload.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "MemoryRegulator.h"
 #include "ProxyWrappers.h"
 #include "PyStrings.h"
 #include "TypeManip.h"
 #include "Utility.h"
 
-#include "CPyCppyy/DispatchPtr.h"
+#include "cpyrt/DispatchPtr.h"
 
 // Standard
 #include <algorithm>
@@ -18,7 +18,7 @@
 
 
 //- data _____________________________________________________________________
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     extern PyObject* gNullPtrObject;
 }
 
@@ -63,13 +63,13 @@ struct ExtendedData {
     void* fObject;
 
 // for caching expensive-to-create data member representations
-    CPyCppyy::CI_DatamemberCache_t fDatamemberCache;
+    cppjit::cpyrt::CI_DatamemberCache_t fDatamemberCache;
 
 // for smart pointer types
-    CPyCppyy::CPPSmartClass* fSmartClass;
+    cppjit::cpyrt::CPPSmartClass* fSmartClass;
 
 // for back-referencing from Python-derived instances
-    CPyCppyy::DispatchPtr* fDispatchPtr;
+    cppjit::cpyrt::DispatchPtr* fDispatchPtr;
 
 // for representing T* as a low-level array
     Py_ssize_t fArraySize;
@@ -84,7 +84,7 @@ struct ExtendedData {
 #define DISPATCHPTR(pyobj) ((ExtendedData*)((pyobj)->fObject))->fDispatchPtr
 #define ARRAY_SIZE(pyobj)  ((ExtendedData*)((pyobj)->fObject))->fArraySize
 
-inline void CPyCppyy::CPPInstance::CreateExtension() {
+inline void cppjit::cpyrt::CPPInstance::CreateExtension() {
     if (fFlags & kIsExtended)
         return;
     void* obj = fObject;
@@ -93,19 +93,19 @@ inline void CPyCppyy::CPPInstance::CreateExtension() {
     fFlags |= kIsExtended;
 }
 
-void* CPyCppyy::CPPInstance::GetExtendedObject()
+void* cppjit::cpyrt::CPPInstance::GetExtendedObject()
 {
     if (IsSmart()) {
     // We get the raw pointer from the smart pointer each time, in case it has
     // changed or has been freed.
-        return Cppyy::CallR(SMART_CLS(this)->fDereferencer, EXT_OBJECT(this), 0, nullptr);
+        return cppjit::interop::CallR(SMART_CLS(this)->fDereferencer, EXT_OBJECT(this), 0, nullptr);
     }
     return EXT_OBJECT(this);
 }
 
 
 //- public methods -----------------------------------------------------------
-CPyCppyy::CPPInstance* CPyCppyy::CPPInstance::Copy(void* cppinst, PyTypeObject* target)
+cppjit::cpyrt::CPPInstance* cppjit::cpyrt::CPPInstance::Copy(void* cppinst, PyTypeObject* target)
 {
 // create a fresh instance; args and kwds are not used by op_new (see below)
     PyObject* self = (PyObject*)this;
@@ -157,7 +157,7 @@ CPyCppyy::CPPInstance* CPyCppyy::CPPInstance::Copy(void* cppinst, PyTypeObject*
 
 
 //----------------------------------------------------------------------------
-void CPyCppyy::CPPInstance::PythonOwns()
+void cppjit::cpyrt::CPPInstance::PythonOwns()
 {
     fFlags |= kIsOwner;
     if ((fFlags & kIsExtended) && DISPATCHPTR(this))
@@ -165,7 +165,7 @@ void CPyCppyy::CPPInstance::PythonOwns()
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::CPPInstance::CppOwns()
+void cppjit::cpyrt::CPPInstance::CppOwns()
 {
     fFlags &= ~kIsOwner;
     if ((fFlags & kIsExtended) && DISPATCHPTR(this))
@@ -173,7 +173,7 @@ void CPyCppyy::CPPInstance::CppOwns()
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::CPPInstance::SetSmart(PyObject* smart_type)
+void cppjit::cpyrt::CPPInstance::SetSmart(PyObject* smart_type)
 {
     CreateExtension();
     Py_INCREF(smart_type);
@@ -182,24 +182,24 @@ void CPyCppyy::CPPInstance::SetSmart(PyObject* smart_type)
 }
 
 //----------------------------------------------------------------------------
-Cppyy::TCppScope_t CPyCppyy::CPPInstance::GetSmartIsA() const
+cppjit::interop::TCppScope_t cppjit::cpyrt::CPPInstance::GetSmartIsA() const
 {
-    if (!IsSmart()) return Cppyy::TCppScope_t{};
+    if (!IsSmart()) return cppjit::interop::TCppScope_t{};
     return SMART_TYPE(this);
 }
 
 //----------------------------------------------------------------------------
-Cppyy::TCppScope_t CPyCppyy::CPPInstance::GetSmartUnderlyingType() const
+cppjit::interop::TCppScope_t cppjit::cpyrt::CPPInstance::GetSmartUnderlyingType() const
 {
 // Declared underlying type of the embedded smart pointer ('Base' for a
 // std::unique_ptr<Base>), independent of any downcast of the dereferenced
 // object.
-    if (!IsSmart()) return Cppyy::TCppScope_t{};
+    if (!IsSmart()) return cppjit::interop::TCppScope_t{};
     return SMART_CLS(this)->fUnderlyingType;
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::CI_DatamemberCache_t& CPyCppyy::CPPInstance::GetDatamemberCache()
+cppjit::cpyrt::CI_DatamemberCache_t& cppjit::cpyrt::CPPInstance::GetDatamemberCache()
 {
 // Return the cache for expensive data objects (and make extended as necessary)
     CreateExtension();
@@ -207,7 +207,7 @@ CPyCppyy::CI_DatamemberCache_t& CPyCppyy::CPPInstance::GetDatamemberCache()
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::CPPInstance::SetDispatchPtr(void* ptr)
+void cppjit::cpyrt::CPPInstance::SetDispatchPtr(void* ptr)
 {
 // Set up the dispatch pointer for memory management
     CreateExtension();
@@ -216,10 +216,10 @@ void CPyCppyy::CPPInstance::SetDispatchPtr(void* ptr)
 
 
 //----------------------------------------------------------------------------
-void CPyCppyy::op_dealloc_nofree(CPPInstance* pyobj) {
+void cppjit::cpyrt::op_dealloc_nofree(CPPInstance* pyobj) {
 // Destroy the held C++ object, if owned; does not deallocate the proxy.
 
-    Cppyy::TCppScope_t klass = pyobj->ObjectIsA(false /* check_smart */);
+    cppjit::interop::TCppScope_t klass = pyobj->ObjectIsA(false /* check_smart */);
     void*& cppobj = pyobj->GetObjectRaw();
 
     if (pyobj->fFlags & CPPInstance::kIsRegulated)
@@ -227,10 +227,10 @@ void CPyCppyy::op_dealloc_nofree(CPPInstance* pyobj) {
 
     if (cppobj && (pyobj->fFlags & CPPInstance::kIsOwner)) {
         if (pyobj->fFlags & CPPInstance::kIsValue) {
-            Cppyy::CallDestructor(klass, cppobj);
-            Cppyy::Deallocate(klass, cppobj);
+            cppjit::interop::CallDestructor(klass, cppobj);
+            cppjit::interop::Deallocate(klass, cppobj);
         } else
-            Cppyy::Destruct(klass, cppobj);
+            cppjit::interop::Destruct(klass, cppobj);
     }
     cppobj = nullptr;
 
@@ -239,7 +239,7 @@ void CPyCppyy::op_dealloc_nofree(CPPInstance* pyobj) {
 }
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 //----------------------------------------------------------------------------
 static int op_traverse(CPPInstance* /*pyobj*/, visitproc /*visit*/, void* /*arg*/)
@@ -248,7 +248,7 @@ static int op_traverse(CPPInstance* /*pyobj*/, visitproc /*visit*/, void* /*arg*
 }
 
 
-//= CPyCppyy object proxy null-ness checking =================================
+//= cpyrt object proxy null-ness checking =================================
 static int op_nonzero(CPPInstance* self)
 {
 // Null of the proxy is determined by null-ness of the held C++ object.
@@ -273,7 +273,7 @@ static int op_nonzero(CPPInstance* self)
     return result;
 }
 
-//= CPyCppyy object explicit destruction =====================================
+//= cpyrt object explicit destruction =====================================
 static PyObject* op_destruct(CPPInstance* self)
 {
 // User access to force deletion of the object. Needed in case of a true
@@ -284,14 +284,14 @@ static PyObject* op_destruct(CPPInstance* self)
     Py_RETURN_NONE;
 }
 
-//= CPyCppyy object dispatch support =========================================
+//= cpyrt object dispatch support =========================================
 static PyObject* op_dispatch(PyObject* self, PyObject* args, PyObject* /* kdws */)
 {
 // User-side __dispatch__ method to allow selection of a specific overloaded
 // method. The actual selection is in the __overload__() method of CPPOverload.
     PyObject *mname = nullptr, *sigarg = nullptr;
     if (!PyArg_ParseTuple(args, const_cast<char*>("O!O!:__dispatch__"),
-            &CPyCppyy_PyText_Type, &mname, &CPyCppyy_PyText_Type, &sigarg))
+            &cpyrt_PyText_Type, &mname, &cpyrt_PyText_Type, &sigarg))
         return nullptr;
 
 // get the named overload
@@ -313,7 +313,7 @@ static PyObject* op_dispatch(PyObject* self, PyObject* args, PyObject* /* kdws *
     return oload;
 }
 
-//= CPyCppyy smart pointer support ===========================================
+//= cpyrt smart pointer support ===========================================
 static PyObject* op_get_smartptr(CPPInstance* self)
 {
     if (!self->IsSmart()) {
@@ -321,18 +321,18 @@ static PyObject* op_get_smartptr(CPPInstance* self)
         Py_RETURN_NONE;
     }
 
-    return CPyCppyy::BindCppObjectNoCast(self->GetSmartObject(), SMART_TYPE(self), CPPInstance::kNoWrapConv);
+    return cppjit::cpyrt::BindCppObjectNoCast(self->GetSmartObject(), SMART_TYPE(self), CPPInstance::kNoWrapConv);
 }
 
 //= pointer-as-array support for legacy C code ===============================
-void CPyCppyy::CPPInstance::CastToArray(Py_ssize_t sz)
+void cppjit::cpyrt::CPPInstance::CastToArray(Py_ssize_t sz)
 {
     CreateExtension();
     fFlags |= kIsArray;
     ARRAY_SIZE(this) = sz;
 }
 
-Py_ssize_t CPyCppyy::CPPInstance::ArrayLength() {
+Py_ssize_t cppjit::cpyrt::CPPInstance::ArrayLength() {
     if (!(fFlags & kIsArray))
         return -1;
     return (Py_ssize_t)ARRAY_SIZE(this);
@@ -388,7 +388,7 @@ static PyObject* op_item(CPPInstance* self, Py_ssize_t idx)
     if (self->fFlags & CPPInstance::kIsPtrPtr) {
         flags = CPPInstance::kIsReference;
     } else {
-        sz = Cppyy::SizeOf(((CPPClass*)Py_TYPE(self))->fCppType);
+        sz = cppjit::interop::SizeOf(((CPPClass*)Py_TYPE(self))->fCppType);
     }
 
     uintptr_t address = (uintptr_t)(flags ? self->GetObjectRaw() : self->GetObject());
@@ -443,7 +443,7 @@ static PyMethodDef op_methods[] = {
 };
 
 
-//= CPyCppyy object proxy construction/destruction ===========================
+//= cpyrt object proxy construction/destruction ===========================
 static CPPInstance* op_new(PyTypeObject* subtype, PyObject*, PyObject*)
 {
 // Create a new object proxy (holder only).
@@ -547,10 +547,10 @@ static inline void* cast_actual(void* obj) {
     if (((CPPInstance*)obj)->fFlags & CPPInstance::kIsActual)
         return address;
 
-    Cppyy::TCppScope_t klass = ((CPPClass*)Py_TYPE((PyObject*)obj))->fCppType;
-    Cppyy::TCppScope_t clActual = klass /* XXX: Cppyy::GetActualClass(klass, address) */;
+    cppjit::interop::TCppScope_t klass = ((CPPClass*)Py_TYPE((PyObject*)obj))->fCppType;
+    cppjit::interop::TCppScope_t clActual = klass /* XXX: cppjit::interop::GetActualClass(klass, address) */;
     if (clActual && clActual != klass) {
-        intptr_t offset = Cppyy::GetBaseOffset(
+        intptr_t offset = cppjit::interop::GetBaseOffset(
              clActual, klass, address, -1 /* down-cast */, true /* report errors */);
         if (offset != -1) address = (void*)((intptr_t)address + offset);
     }
@@ -559,7 +559,7 @@ static inline void* cast_actual(void* obj) {
 }
 
 
-#define CPYCPPYY_ORDERED_OPERATOR_STUB(op, ometh, label)                      \
+#define CPYRT_ORDERED_OPERATOR_STUB(op, ometh, label)                      \
     if (!ometh) {                                                             \
         PyCallable* pyfunc = Utility::FindBinaryOperator((PyObject*)self, other, #op);\
         if (pyfunc)                                                           \
@@ -631,16 +631,16 @@ static PyObject* op_richcompare(CPPInstance* self, PyObject* other, int op)
 
         switch (op) {
         case Py_LT:
-            CPYCPPYY_ORDERED_OPERATOR_STUB(<,  klass->fOperators->fLt, __lt__)
+            CPYRT_ORDERED_OPERATOR_STUB(<,  klass->fOperators->fLt, __lt__)
             break;
         case Py_LE:
-            CPYCPPYY_ORDERED_OPERATOR_STUB(<=, klass->fOperators->fLe, __le__)
+            CPYRT_ORDERED_OPERATOR_STUB(<=, klass->fOperators->fLe, __le__)
             break;
         case Py_GT:
-            CPYCPPYY_ORDERED_OPERATOR_STUB(>,  klass->fOperators->fGt, __gt__)
+            CPYRT_ORDERED_OPERATOR_STUB(>,  klass->fOperators->fGt, __gt__)
             break;
         case Py_GE:
-            CPYCPPYY_ORDERED_OPERATOR_STUB(>=, klass->fOperators->fGe, __ge__)
+            CPYRT_ORDERED_OPERATOR_STUB(>=, klass->fOperators->fGe, __ge__)
             break;
         }
 
@@ -666,8 +666,8 @@ static PyObject* op_repr(CPPInstance* self)
         return PyBaseObject_Type.tp_repr((PyObject*)self);
     PyObject* modname = PyObject_GetAttr(pyclass, PyStrings::gModule);
 
-    Cppyy::TCppScope_t klass = self->ObjectIsA();
-    std::string clName = klass ? Cppyy::GetFinalName(klass) : "<unknown>";
+    cppjit::interop::TCppScope_t klass = self->ObjectIsA();
+    std::string clName = klass ? cppjit::interop::GetFinalName(klass) : "<unknown>";
     if (self->fFlags & CPPInstance::kIsPtrPtr)
         clName.append("**");
     else if (self->fFlags & CPPInstance::kIsReference)
@@ -675,14 +675,14 @@ static PyObject* op_repr(CPPInstance* self)
 
     PyObject* repr = nullptr;
     if (self->IsSmart()) {
-        std::string smartPtrName = Cppyy::GetScopedFinalName(SMART_TYPE(self));
-        repr = CPyCppyy_PyText_FromFormat(
+        std::string smartPtrName = cppjit::interop::GetScopedFinalName(SMART_TYPE(self));
+        repr = cpyrt_PyText_FromFormat(
             const_cast<char*>("<%s.%s object at %p held by %s at %p>"),
-            CPyCppyy_PyText_AsString(modname), clName.c_str(),
+            cpyrt_PyText_AsString(modname), clName.c_str(),
             self->GetObject(), smartPtrName.c_str(), self->GetObjectRaw());
     } else {
-        repr = CPyCppyy_PyText_FromFormat(const_cast<char*>("<%s.%s object at %p>"),
-            CPyCppyy_PyText_AsString(modname), clName.c_str(), self->GetObject());
+        repr = cpyrt_PyText_FromFormat(const_cast<char*>("<%s.%s object at %p>"),
+            cpyrt_PyText_AsString(modname), clName.c_str(), self->GetObject());
     }
 
     Py_DECREF(modname);
@@ -690,7 +690,7 @@ static PyObject* op_repr(CPPInstance* self)
 }
 
 //----------------------------------------------------------------------------
-static inline Py_hash_t CPyCppyy_PyLong_AsHash_t(PyObject* obj)
+static inline Py_hash_t cpyrt_PyLong_AsHash_t(PyObject* obj)
 {
 // Cannot use PyLong_AsSize_t here, as it cuts of at PY_SSIZE_T_MAX, which is
 // only half of the max of std::size_t returned by the hash.
@@ -707,13 +707,13 @@ static Py_hash_t op_hash(CPPInstance* self)
         Py_hash_t h = 0;
         PyObject* hashval = PyObject_CallFunctionObjArgs(klass->fOperators->fHash, (PyObject*)self, nullptr);
         if (hashval) {
-            h = CPyCppyy_PyLong_AsHash_t(hashval);
+            h = cpyrt_PyLong_AsHash_t(hashval);
             Py_DECREF(hashval);
         }
         return h;
     }
 
-    Cppyy::TCppScope_t stdhash = Cppyy::GetFullScope("std::hash<"+Cppyy::GetScopedFinalName(self->ObjectIsA())+">");
+    cppjit::interop::TCppScope_t stdhash = cppjit::interop::GetFullScope("std::hash<"+cppjit::interop::GetScopedFinalName(self->ObjectIsA())+">");
     if (stdhash) {
         PyObject* hashcls = CreateScopeProxy(stdhash);
         PyObject* dct = PyObject_GetAttr(hashcls, PyStrings::gDict);
@@ -728,7 +728,7 @@ static Py_hash_t op_hash(CPPInstance* self)
             Py_hash_t h = 0;
             PyObject* hashval = PyObject_CallFunctionObjArgs(hashobj, (PyObject*)self, nullptr);
             if (hashval) {
-                h = CPyCppyy_PyLong_AsHash_t(hashval);
+                h = cpyrt_PyLong_AsHash_t(hashval);
                 Py_DECREF(hashval);
             }
             return h;
@@ -744,7 +744,7 @@ static Py_hash_t op_hash(CPPInstance* self)
 //----------------------------------------------------------------------------
 static PyObject* op_str_internal(PyObject* pyobj, PyObject* lshift, bool isBound)
 {
-    static Cppyy::TCppScope_t sOStringStreamID = Cppyy::GetFullScope("std::ostringstream");
+    static cppjit::interop::TCppScope_t sOStringStreamID = cppjit::interop::GetFullScope("std::ostringstream");
     std::ostringstream s;
     PyObject* pys = BindCppObjectNoCast(&s, sOStringStreamID);
     Py_INCREF(pys);
@@ -762,7 +762,7 @@ static PyObject* op_str_internal(PyObject* pyobj, PyObject* lshift, bool isBound
 
     if (res) {
         Py_DECREF(res);
-        return CPyCppyy_PyText_FromString(s.str().c_str());
+        return cpyrt_PyText_FromString(s.str().c_str());
     }
 
     return nullptr;
@@ -800,7 +800,7 @@ static PyObject* op_str(CPPInstance* self)
             else if (pyname == (PyObject*)0x01) {
             // normal lookup failed; attempt lazy install of global operator<<(ostream&, type&)
                 std::string rcname = Utility::ClassName((PyObject*)self);
-                Cppyy::TCppScope_t rnsID = Cppyy::GetScope(TypeManip::extract_namespace(rcname));
+                cppjit::interop::TCppScope_t rnsID = cppjit::interop::GetScope(TypeManip::extract_namespace(rcname));
                 PyCallable* pyfunc = Utility::FindBinaryOperator("std::ostream&", rcname, "<<", rnsID);
                 if (!pyfunc)
                      continue;
@@ -813,9 +813,9 @@ static PyObject* op_str(CPPInstance* self)
             } else if (pyname == (PyObject*)0x02) {
             // TODO: the only reason this still exists, is b/c friend functions are otherwise not found
             // TODO: ToString() still leaks ...
-                const std::string& pretty = Cppyy::ToString(self->ObjectIsA(), self->GetObject());
+                const std::string& pretty = cppjit::interop::ToString(self->ObjectIsA(), self->GetObject());
                 if (!pretty.empty())
-                    return CPyCppyy_PyText_FromString(pretty.c_str());
+                    return cpyrt_PyText_FromString(pretty.c_str());
                 continue;
             }
 
@@ -840,7 +840,7 @@ static PyObject* op_str(CPPInstance* self)
     if (!ScopeFlagCheck(self, CPPScope::kNoPrettyPrint)) {
         static PyObject* printValue = nullptr;
         if (!printValue) {
-            PyObject* gbl = PyDict_GetItemString(PySys_GetObject((char*)"modules"), "cppyy.gbl");
+            PyObject* gbl = PyDict_GetItemString(PySys_GetObject((char*)"modules"), "cppjit.gbl");
             PyObject* cl  = PyObject_GetAttrString(gbl, (char*)"cling");
             printValue    = PyObject_GetAttrString(cl,  (char*)"printValue");
             Py_DECREF(cl);
@@ -857,17 +857,17 @@ static PyObject* op_str(CPPInstance* self)
         if (printValue) {
         // as printValue only works well for templates taking pointer arguments, we'll
         // have to force the issue by working with a by-ptr object
-            Cppyy::TCppObject_t cppobj = self->GetObjectRaw();
+            cppjit::interop::TCppObject_t cppobj = self->GetObjectRaw();
             PyObject* byref = (PyObject*)self;
             if (!(self->fFlags & CPPInstance::kIsReference)) {
-                byref = BindCppObjectNoCast((Cppyy::TCppObject_t)&cppobj,
+                byref = BindCppObjectNoCast((cppjit::interop::TCppObject_t)&cppobj,
                     self->ObjectIsA(), CPPInstance::kIsReference | CPPInstance::kNoMemReg);
             } else {
                 Py_INCREF(byref);
             }
 
         // explicit template lookup
-            PyObject* clName = CPyCppyy_PyText_FromString(Utility::ClassName((PyObject*)self).c_str());
+            PyObject* clName = cpyrt_PyText_FromString(Utility::ClassName((PyObject*)self).c_str());
             PyObject* OL = PyObject_GetItem(printValue, clName);
             Py_DECREF(clName);
 
@@ -879,7 +879,7 @@ static PyObject* op_str(CPPInstance* self)
             if (pretty) {
                 const std::string& pv = *(std::string*)((CPPInstance*)pretty)->GetObject();
                 if (!pv.empty() && pv.find("@0x") == std::string::npos)
-                    result = CPyCppyy_PyText_FromString(pv.c_str());
+                    result = cpyrt_PyText_FromString(pv.c_str());
                 Py_DECREF(pretty);
                 if (result) return result;
             }
@@ -925,8 +925,8 @@ static PyGetSetDef op_getset[] = {
 };
 
 
-//= CPyCppyy type number stubs to allow dynamic overrides =====================
-#define CPYCPPYY_STUB_BODY(name, op)                                          \
+//= cpyrt type number stubs to allow dynamic overrides =====================
+#define CPYRT_STUB_BODY(name, op)                                          \
     bool previously_resolved_overload = (bool)meth;                           \
     if (!meth) {                                                              \
         PyErr_Clear();                                                        \
@@ -953,7 +953,7 @@ static PyGetSetDef op_getset[] = {
     return res;
 
 
-#define CPYCPPYY_OPERATOR_STUB(name, op, ometh)                               \
+#define CPYRT_OPERATOR_STUB(name, op, ometh)                               \
 static PyObject* op_##name##_stub(PyObject* left, PyObject* right)            \
 {                                                                             \
 /* placeholder to lazily install and forward to 'ometh' if available */       \
@@ -961,10 +961,10 @@ static PyObject* op_##name##_stub(PyObject* left, PyObject* right)            \
     if (!klass->fOperators) klass->fOperators = new Utility::PyOperators{};   \
     PyObject*& meth = ometh;                                                  \
     PyObject *cppobj = left, *other = right;                                  \
-    CPYCPPYY_STUB_BODY(name, op)                                              \
+    CPYRT_STUB_BODY(name, op)                                              \
 }
 
-#define CPYCPPYY_ASSOCIATIVE_OPERATOR_STUB(name, op, lmeth, rmeth)            \
+#define CPYRT_ASSOCIATIVE_OPERATOR_STUB(name, op, lmeth, rmeth)            \
 static PyObject* op_##name##_stub(PyObject* left, PyObject* right)            \
 {                                                                             \
 /* placeholder to lazily install and forward do '(l/r)meth' if available  */  \
@@ -983,10 +983,10 @@ static PyObject* op_##name##_stub(PyObject* left, PyObject* right)            \
         return nullptr;                                                       \
     }                                                                         \
     PyObject*& meth = *pmeth;                                                 \
-    CPYCPPYY_STUB_BODY(name, op)                                              \
+    CPYRT_STUB_BODY(name, op)                                              \
 }
 
-#define CPYCPPYY_UNARY_OPERATOR(name, op, label)                              \
+#define CPYRT_UNARY_OPERATOR(name, op, label)                              \
 static PyObject* op_##name##_stub(PyObject* pyobj)                            \
 {                                                                             \
 /* placeholder to lazily install unary operators */                           \
@@ -997,13 +997,13 @@ static PyObject* op_##name##_stub(PyObject* pyobj)                            \
     return nullptr;                                                           \
 }
 
-CPYCPPYY_ASSOCIATIVE_OPERATOR_STUB(add, +, klass->fOperators->fLAdd, klass->fOperators->fRAdd)
-CPYCPPYY_OPERATOR_STUB(            sub, -, klass->fOperators->fSub)
-CPYCPPYY_ASSOCIATIVE_OPERATOR_STUB(mul, *, klass->fOperators->fLMul, klass->fOperators->fRMul)
-CPYCPPYY_OPERATOR_STUB(            div, /, klass->fOperators->fDiv)
-CPYCPPYY_UNARY_OPERATOR(neg,    -, __neg__)
-CPYCPPYY_UNARY_OPERATOR(pos,    +, __pos__)
-CPYCPPYY_UNARY_OPERATOR(invert, ~, __invert__)
+CPYRT_ASSOCIATIVE_OPERATOR_STUB(add, +, klass->fOperators->fLAdd, klass->fOperators->fRAdd)
+CPYRT_OPERATOR_STUB(            sub, -, klass->fOperators->fSub)
+CPYRT_ASSOCIATIVE_OPERATOR_STUB(mul, *, klass->fOperators->fLMul, klass->fOperators->fRMul)
+CPYRT_OPERATOR_STUB(            div, /, klass->fOperators->fDiv)
+CPYRT_UNARY_OPERATOR(neg,    -, __neg__)
+CPYRT_UNARY_OPERATOR(pos,    +, __pos__)
+CPYRT_UNARY_OPERATOR(invert, ~, __invert__)
 
 //-----------------------------------------------------------------------------
 static PyNumberMethods op_as_number = {
@@ -1046,10 +1046,10 @@ static PyNumberMethods op_as_number = {
 };
 
 
-//= CPyCppyy object proxy type ===============================================
+//= cpyrt object proxy type ===============================================
 PyTypeObject CPPInstance_Type = {
     PyVarObject_HEAD_INIT(&CPPScope_Type, 0)
-    (char*)"cppyy.CPPInstance",    // tp_name
+    (char*)"cppjit.CPPInstance",    // tp_name
     sizeof(CPPInstance),           // tp_basicsize
     0,                             // tp_itemsize
     (destructor)op_dealloc,        // tp_dealloc
@@ -1071,7 +1071,7 @@ PyTypeObject CPPInstance_Type = {
         Py_TPFLAGS_BASETYPE |
         Py_TPFLAGS_CHECKTYPES |
         Py_TPFLAGS_HAVE_GC,        // tp_flags
-    (char*)"cppyy object proxy (internal)", // tp_doc
+    (char*)"cppjit object proxy (internal)", // tp_doc
     (traverseproc)op_traverse,     // tp_traverse
     (inquiry)op_clear,             // tp_clear
     (richcmpfunc)op_richcompare,   // tp_richcompare
@@ -1100,7 +1100,7 @@ PyTypeObject CPPInstance_Type = {
     0,                             // tp_version_tag
     0,                             // tp_finalize
     0                              // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
diff --git a/src/CPyCppyy/src/CPPInstance.h b/src/cpyrt/CPPInstance.h
similarity index 89%
rename from src/CPyCppyy/src/CPPInstance.h
rename to src/cpyrt/CPPInstance.h
index 3482cd0..8611bfb 100644
--- a/src/CPyCppyy/src/CPPInstance.h
+++ b/src/cpyrt/CPPInstance.h
@@ -1,9 +1,9 @@
-#ifndef CPYCPPYY_CPPINSTANCE_H
-#define CPYCPPYY_CPPINSTANCE_H
+#ifndef CPYRT_CPPINSTANCE_H
+#define CPYRT_CPPINSTANCE_H
 
 //////////////////////////////////////////////////////////////////////////////
 //                                                                          //
-// CpyCppyy::CPPInstance                                                    //
+// Cpycppjit::interop::CPPInstance                                                    //
 //                                                                          //
 // Python-side proxy, encapsulaties a C++ object.                           //
 //                                                                          //
@@ -13,7 +13,7 @@
 #ifndef Py_LIMITED_API
 #include "CPPScope.h"
 #endif
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "CallContext.h"     // for Parameter
 
 // Standard
@@ -21,7 +21,7 @@
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 typedef std::vector<std::pair<ptrdiff_t, PyObject*>> CI_DatamemberCache_t;
 
@@ -64,7 +64,7 @@ class CPPInstance {
 // access to C++ pointer and type
     void*  GetObject();
     void*& GetObjectRaw() { return IsExtended() ? *(void**) fObject : fObject; }
-    Cppyy::TCppScope_t ObjectIsA(bool check_smart = true) const;
+    cppjit::interop::TCppScope_t ObjectIsA(bool check_smart = true) const;
 
 // memory management: ownership of the underlying C++ object
     void PythonOwns();
@@ -76,8 +76,8 @@ class CPPInstance {
 // smart pointer management
     void SetSmart(PyObject* smart_type);
     void* GetSmartObject() { return GetObjectRaw(); }
-    Cppyy::TCppScope_t GetSmartIsA() const;
-    Cppyy::TCppScope_t GetSmartUnderlyingType() const;
+    cppjit::interop::TCppScope_t GetSmartIsA() const;
+    cppjit::interop::TCppScope_t GetSmartUnderlyingType() const;
 
 // cross-inheritance dispatch
     void SetDispatchPtr(void*);
@@ -121,7 +121,7 @@ inline void* CPPInstance::GetObject()
 
 #ifndef Py_LIMITED_API
 //----------------------------------------------------------------------------
-inline Cppyy::TCppScope_t CPPInstance::ObjectIsA(bool check_smart) const
+inline cppjit::interop::TCppScope_t CPPInstance::ObjectIsA(bool check_smart) const
 {
 // Retrieve the C++ type identifier (or raw type if smart).
     if (check_smart || !IsSmart()) return ((CPPClass*)Py_TYPE(this))->fCppType;
@@ -130,7 +130,7 @@ inline Cppyy::TCppScope_t CPPInstance::ObjectIsA(bool check_smart) const
 #endif
 
 //- object proxy type and type verification ----------------------------------
-CPYCPPYY_IMPORT PyTypeObject CPPInstance_Type;
+CPYRT_IMPORT PyTypeObject CPPInstance_Type;
 
 #ifndef Py_LIMITED_API
 template<typename T>
@@ -154,6 +154,6 @@ inline bool CPPInstance_CheckExact(T* object)
 //- helper for memory regulation (no PyTypeObject equiv. member in p2.2) -----
 void op_dealloc_nofree(CPPInstance*);
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPINSTANCE_H
+#endif // !CPYRT_CPPINSTANCE_H
diff --git a/src/CPyCppyy/src/CPPMethod.cxx b/src/cpyrt/CPPMethod.cxx
similarity index 72%
rename from src/CPyCppyy/src/CPPMethod.cxx
rename to src/cpyrt/CPPMethod.cxx
index 5bbf30c..b49b5e4 100644
--- a/src/CPyCppyy/src/CPPMethod.cxx
+++ b/src/cpyrt/CPPMethod.cxx
@@ -1,10 +1,10 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPMethod.h"
 #include "CPPExcInstance.h"
 #include "CPPInstance.h"
 #include "Converters.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "Executors.h"
 #include "ProxyWrappers.h"
 #include "PyStrings.h"
@@ -12,7 +12,7 @@
 #include "SignalTryCatch.h"
 #include "Utility.h"
 
-#include "CPyCppyy/PyException.h"
+#include "cpyrt/PyException.h"
 
 // Standard
 #include <algorithm>
@@ -27,7 +27,7 @@
 
 
 //- data and local helpers ---------------------------------------------------
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     extern PyObject* gThisModule;
     extern PyObject* gBusException;
     extern PyObject* gSegvException;
@@ -37,14 +37,14 @@ namespace CPyCppyy {
 
 
 //- public helper ------------------------------------------------------------
-CPyCppyy::PyCallArgs::~PyCallArgs() {
+cppjit::cpyrt::PyCallArgs::~PyCallArgs() {
     if (fFlags & kSelfSwap)            // if self swap, fArgs has been offset by -1
         std::swap((PyObject*&)fSelf, ((PyObject**)fArgs)[0]);
 
     if (fFlags & kIsOffset) fArgs -= 1;
 
     if (fFlags & kDoItemDecref) {
-        for (Py_ssize_t iarg = 0; iarg < CPyCppyy_PyArgs_GET_SIZE(fArgs, fNArgsf); ++iarg)
+        for (Py_ssize_t iarg = 0; iarg < cpyrt_PyArgs_GET_SIZE(fArgs, fNArgsf); ++iarg)
             Py_DECREF(fArgs[iarg]);
     }
 
@@ -59,18 +59,18 @@ CPyCppyy::PyCallArgs::~PyCallArgs() {
 
 
 //- private helpers ----------------------------------------------------------
-inline bool CPyCppyy::CPPMethod::VerifyArgCount_(Py_ssize_t actual)
+inline bool cppjit::cpyrt::CPPMethod::VerifyArgCount_(Py_ssize_t actual)
 {
 // actual number of arguments must be between required and max args
     Py_ssize_t maxargs = (Py_ssize_t)fConverters.size();
 
     if (maxargs != actual) {
         if (actual < (Py_ssize_t)fArgsRequired) {
-            SetPyError_(CPyCppyy_PyText_FromFormat(
+            SetPyError_(cpyrt_PyText_FromFormat(
                 "takes at least %d arguments (%zd given)", fArgsRequired, actual));
             return false;
         } else if (maxargs < actual) {
-            SetPyError_(CPyCppyy_PyText_FromFormat(
+            SetPyError_(cpyrt_PyText_FromFormat(
                 "takes at most %zd arguments (%zd given)", maxargs, actual));
             return false;
         }
@@ -79,7 +79,7 @@ inline bool CPyCppyy::CPPMethod::VerifyArgCount_(Py_ssize_t actual)
 }
 
 //----------------------------------------------------------------------------
-inline void CPyCppyy::CPPMethod::Copy_(const CPPMethod& /* other */)
+inline void cppjit::cpyrt::CPPMethod::Copy_(const CPPMethod& /* other */)
 {
 // fScope and fMethod handled separately
 
@@ -90,7 +90,7 @@ inline void CPyCppyy::CPPMethod::Copy_(const CPPMethod& /* other */)
 }
 
 //----------------------------------------------------------------------------
-inline void CPyCppyy::CPPMethod::Destroy_()
+inline void cppjit::cpyrt::CPPMethod::Destroy_()
 {
 // destroy executor and argument converters
     if (fExecutor && fExecutor->HasState()) delete fExecutor;
@@ -106,7 +106,7 @@ inline void CPyCppyy::CPPMethod::Destroy_()
 }
 
 //----------------------------------------------------------------------------
-inline PyObject* CPyCppyy::CPPMethod::ExecuteFast(
+inline PyObject* cppjit::cpyrt::CPPMethod::ExecuteFast(
     void* self, ptrdiff_t offset, CallContext* ctxt)
 {
 // call into C++ through fExecutor; abstracted out from Execute() to prevent some
@@ -114,13 +114,13 @@ inline PyObject* CPyCppyy::CPPMethod::ExecuteFast(
     PyObject* result = nullptr;
 
     try {       // C++ try block
-        result = fExecutor->Execute(fMethod, Cppyy::TCppObject_t((void*)((intptr_t)self+offset)), ctxt);
+        result = fExecutor->Execute(fMethod, cppjit::interop::TCppObject_t((void*)((intptr_t)self+offset)), ctxt);
     } catch (PyException&) {
         ctxt->fFlags |= CallContext::kPyException;
         result = nullptr;           // error already set
     } catch (std::exception& e) {
     // attempt to set the exception to the actual type, to allow catching with the Python C++ type
-        static Cppyy::TCppScope_t exc_type = Cppyy::GetFullScope("std::exception");
+        static cppjit::interop::TCppScope_t exc_type = cppjit::interop::GetFullScope("std::exception");
 
         ctxt->fFlags |= CallContext::kCppException;
 
@@ -129,8 +129,8 @@ inline PyObject* CPyCppyy::CPPMethod::ExecuteFast(
 
     // TODO: factor this code with the same in ProxyWrappers (and cache it there to be able to
     // look up based on TCppType_t):
-        Cppyy::TCppScope_t actual = Cppyy::GetActualClass(exc_type, &e);
-        const std::string& finalname = Cppyy::GetScopedFinalName(actual);
+        cppjit::interop::TCppScope_t actual = cppjit::interop::GetActualClass(exc_type, &e);
+        const std::string& finalname = cppjit::interop::GetScopedFinalName(actual);
         const std::string& parentname = TypeManip::extract_namespace(finalname);
         PyObject* parent = CreateScopeProxy(parentname);
         if (parent) {
@@ -141,7 +141,7 @@ inline PyObject* CPyCppyy::CPPMethod::ExecuteFast(
 
         if (pyexc_type) {
         // create a copy of the exception (TODO: factor this code with the same in ProxyWrappers)
-            PyObject* pyclass = CPyCppyy::GetScopeProxy(actual);
+            PyObject* pyclass = cppjit::cpyrt::GetScopeProxy(actual);
             PyObject* source = BindCppObjectNoCast(&e, actual);
             PyObject* pyexc_copy = PyObject_CallFunctionObjArgs(pyclass, source, nullptr);
             Py_DECREF(source);
@@ -185,7 +185,7 @@ inline PyObject* CPyCppyy::CPPMethod::ExecuteFast(
 }
 
 //----------------------------------------------------------------------------
-inline PyObject* CPyCppyy::CPPMethod::ExecuteProtected(
+inline PyObject* cppjit::cpyrt::CPPMethod::ExecuteProtected(
     void* self, ptrdiff_t offset, CallContext* ctxt)
 {
 // helper code to prevent some code duplication; this code embeds a "try/catch"
@@ -223,19 +223,19 @@ inline PyObject* CPyCppyy::CPPMethod::ExecuteProtected(
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::CPPMethod::InitConverters_()
+bool cppjit::cpyrt::CPPMethod::InitConverters_()
 {
 // build buffers for argument dispatching
-    const size_t nArgs = Cppyy::GetMethodNumArgs(fMethod);
+    const size_t nArgs = cppjit::interop::GetMethodNumArgs(fMethod);
     fConverters.resize(nArgs);
 
 // setup the dispatch cache
     for (int iarg = 0; iarg < (int)nArgs; ++iarg) {
-        Cppyy::TCppType_t fullType = Cppyy::GetMethodArgType(fMethod, iarg);
+        cppjit::interop::TCppType_t fullType = cppjit::interop::GetMethodArgType(fMethod, iarg);
         Converter* conv = CreateConverter(fullType);
         if (!conv) {
             PyErr_Format(PyExc_TypeError, "argument type %s not handled",
-                Cppyy::GetTypeAsString(fullType).c_str());
+                cppjit::interop::GetTypeAsString(fullType).c_str());
             return false;
         }
 
@@ -246,12 +246,12 @@ bool CPyCppyy::CPPMethod::InitConverters_()
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::CPPMethod::InitExecutor_(Executor*& executor, CallContext* /* ctxt */)
+bool cppjit::cpyrt::CPPMethod::InitExecutor_(Executor*& executor, CallContext* /* ctxt */)
 {
 // install executor conform to the return type
     executor =
-        (bool)fMethod == true ? CreateExecutor(Cppyy::GetMethodReturnType(fMethod)) \
-                              : CreateExecutor(Cppyy::GetScopedFinalName(fScope));
+        (bool)fMethod == true ? CreateExecutor(cppjit::interop::GetMethodReturnType(fMethod)) \
+                              : CreateExecutor(cppjit::interop::GetScopedFinalName(fScope));
 
     if (!executor)
         return false;
@@ -260,14 +260,14 @@ bool CPyCppyy::CPPMethod::InitExecutor_(Executor*& executor, CallContext* /* ctx
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::CPPMethod::GetSignatureString(bool fa)
+std::string cppjit::cpyrt::CPPMethod::GetSignatureString(bool fa)
 {
 // built a signature representation (used for doc strings)
-    return Cppyy::GetMethodSignature(fMethod, fa);
+    return cppjit::interop::GetMethodSignature(fMethod, fa);
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::CPPMethod::SetPyError_(PyObject* msg)
+void cppjit::cpyrt::CPPMethod::SetPyError_(PyObject* msg)
 {
 // Helper to report errors in a consistent format (derefs msg).
 //
@@ -319,17 +319,17 @@ void CPyCppyy::CPPMethod::SetPyError_(PyObject* msg)
  // no traceback, extract its message and fall through
          PyObject* descr = PyObject_Str(evalue);
          if (descr) {
-             details = CPyCppyy_PyText_AsString(descr);
+             details = cpyrt_PyText_AsString(descr);
              Py_DECREF(descr);
          }
      }
 
     PyObject* doc = GetDocString();
-    const char* cdoc = CPyCppyy_PyText_AsString(doc);
-    const char* cmsg = msg ? CPyCppyy_PyText_AsString(msg) : nullptr;
+    const char* cdoc = cpyrt_PyText_AsString(doc);
+    const char* cmsg = msg ? cpyrt_PyText_AsString(msg) : nullptr;
     PyObject* errtype = etype ? etype : PyExc_TypeError;
     PyObject* pyname = PyObject_GetAttr(errtype, PyStrings::gName);
-    const char* cname = pyname ? CPyCppyy_PyText_AsString(pyname) : "Exception";
+    const char* cname = pyname ? cpyrt_PyText_AsString(pyname) : "Exception";
 
     if (!isCppExc) {
     // this is the case where no Python error has occured yet, or an internal
@@ -346,9 +346,9 @@ void CPyCppyy::CPPMethod::SetPyError_(PyObject* msg)
         PyObject *&topMessage = ((CPPExcInstance*)evalue)->fTopMessage;
         Py_XDECREF(topMessage);
         if (msg) {
-            topMessage = CPyCppyy_PyText_FromFormat("%s =>\n    %s: %s | ", cdoc, cname, cmsg);
+            topMessage = cpyrt_PyText_FromFormat("%s =>\n    %s: %s | ", cdoc, cname, cmsg);
         } else {
-            topMessage = CPyCppyy_PyText_FromFormat("%s =>\n    %s: ", cdoc, cname);
+            topMessage = cpyrt_PyText_FromFormat("%s =>\n    %s: ", cdoc, cname);
         }
         // restore the updated error
 #if PY_VERSION_HEX >= 0x030c0000
@@ -363,30 +363,30 @@ void CPyCppyy::CPPMethod::SetPyError_(PyObject* msg)
     Py_XDECREF(msg);
 }
 
-extern std::unordered_map<Cppyy::TCppType_t, Cppyy::TCppType_t> TypeReductionMap;
+extern std::unordered_map<cppjit::interop::TCppType_t, cppjit::interop::TCppType_t> TypeReductionMap;
 
 //- constructors and destructor ----------------------------------------------
-CPyCppyy::CPPMethod::CPPMethod(
-        Cppyy::TCppScope_t scope, Cppyy::TCppMethod_t method) :
+cppjit::cpyrt::CPPMethod::CPPMethod(
+        cppjit::interop::TCppScope_t scope, cppjit::interop::TCppMethod_t method) :
     fMethod(method), fScope(scope), fExecutor(nullptr), fArgIndices(nullptr),
     fArgsRequired(-1)
 {
-   Cppyy::TCppType_t result = Cppyy::ResolveType(Cppyy::GetMethodReturnType(fMethod));
+   cppjit::interop::TCppType_t result = cppjit::interop::ResolveType(cppjit::interop::GetMethodReturnType(fMethod));
     if (TypeReductionMap.find(result) != TypeReductionMap.end())
-        fMethod = Cppyy::ReduceReturnType(fMethod, TypeReductionMap[result]);
-    if (result && Cppyy::IsLambdaClass(result))
-        fMethod = Cppyy::AdaptFunctionForLambdaReturn(fMethod);
+        fMethod = cppjit::interop::ReduceReturnType(fMethod, TypeReductionMap[result]);
+    if (result && cppjit::interop::IsLambdaClass(result))
+        fMethod = cppjit::interop::AdaptFunctionForLambdaReturn(fMethod);
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::CPPMethod::CPPMethod(const CPPMethod& other) :
+cppjit::cpyrt::CPPMethod::CPPMethod(const CPPMethod& other) :
     PyCallable(other), fMethod(other.fMethod), fScope(other.fScope)
 {
     Copy_(other);
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::CPPMethod& CPyCppyy::CPPMethod::operator=(const CPPMethod& other)
+cppjit::cpyrt::CPPMethod& cppjit::cpyrt::CPPMethod::operator=(const CPPMethod& other)
 {
     if (this != &other) {
         Destroy_();
@@ -399,7 +399,7 @@ CPyCppyy::CPPMethod& CPyCppyy::CPPMethod::operator=(const CPPMethod& other)
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::CPPMethod::~CPPMethod()
+cppjit::cpyrt::CPPMethod::~CPPMethod()
 {
     Destroy_();
 }
@@ -427,45 +427,45 @@ CPyCppyy::CPPMethod::~CPPMethod()
  * 'int foo(int x)'
  * 'int a::b::c::foo(int x)'
  */
-PyObject* CPyCppyy::CPPMethod::GetPrototype(bool fa)
+PyObject* cppjit::cpyrt::CPPMethod::GetPrototype(bool fa)
 {
     // Gather the fully qualified final scope of the method. This includes
     // all namespaces up to the one where the method is declared, for example:
     // namespace a { namespace b { void foo(); }}
     // gives
     // a::b
-    std::string finalscope = Cppyy::GetScopedFinalName(fScope);
-    return CPyCppyy_PyText_FromFormat("%s%s %s%s",
-        (Cppyy::IsStaticMethod(fMethod) ? "static " : ""),
-        Cppyy::GetMethodReturnTypeAsString(fMethod).c_str(),
-        Cppyy::GetScopedFinalName(Cppyy::TCppScope_t(fMethod.data)).c_str(),
+    std::string finalscope = cppjit::interop::GetScopedFinalName(fScope);
+    return cpyrt_PyText_FromFormat("%s%s %s%s",
+        (cppjit::interop::IsStaticMethod(fMethod) ? "static " : ""),
+        cppjit::interop::GetMethodReturnTypeAsString(fMethod).c_str(),
+        cppjit::interop::GetScopedFinalName(cppjit::interop::TCppScope_t(fMethod.data)).c_str(),
         GetSignatureString(fa).c_str());
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPMethod::GetTypeName()
+PyObject* cppjit::cpyrt::CPPMethod::GetTypeName()
 {
-    PyObject* cppname = CPyCppyy_PyText_FromString(
+    PyObject* cppname = cpyrt_PyText_FromString(
         (GetReturnTypeName() + \
-        " (" + (fScope ? Cppyy::GetScopedFinalName(fScope) + "::*)" : "*)")).c_str());
-    CPyCppyy_PyText_AppendAndDel(&cppname, GetSignature(false /* show_formalargs */));
+        " (" + (fScope ? cppjit::interop::GetScopedFinalName(fScope) + "::*)" : "*)")).c_str());
+    cpyrt_PyText_AppendAndDel(&cppname, GetSignature(false /* show_formalargs */));
     return cppname;
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPMethod::Reflex(Cppyy::Reflex::RequestId_t request, Cppyy::Reflex::FormatId_t format)
+PyObject* cppjit::cpyrt::CPPMethod::Reflex(cppjit::interop::Reflex::RequestId_t request, cppjit::interop::Reflex::FormatId_t format)
 {
 // C++ reflection tooling for methods.
 
-    if (request == Cppyy::Reflex::RETURN_TYPE) {
+    if (request == cppjit::interop::Reflex::RETURN_TYPE) {
         std::string rtn = GetReturnTypeName();
-        Cppyy::TCppScope_t scope = nullptr;
-        if (format == Cppyy::Reflex::OPTIMAL || format == Cppyy::Reflex::AS_TYPE)
-            scope = Cppyy::GetScope(rtn);
+        cppjit::interop::TCppScope_t scope = nullptr;
+        if (format == cppjit::interop::Reflex::OPTIMAL || format == cppjit::interop::Reflex::AS_TYPE)
+            scope = cppjit::interop::GetScope(rtn);
 
-        if (format == Cppyy::Reflex::AS_STRING || (format == Cppyy::Reflex::OPTIMAL && !scope))
-            return CPyCppyy_PyText_FromString(rtn.c_str());
-        else if (format == Cppyy::Reflex::AS_TYPE || format == Cppyy::Reflex::OPTIMAL) {
+        if (format == cppjit::interop::Reflex::AS_STRING || (format == cppjit::interop::Reflex::OPTIMAL && !scope))
+            return cpyrt_PyText_FromString(rtn.c_str());
+        else if (format == cppjit::interop::Reflex::AS_TYPE || format == cppjit::interop::Reflex::OPTIMAL) {
             if (scope) return CreateScopeProxy(scope);
             /* TODO: builtins as type */
         }
@@ -475,7 +475,7 @@ PyObject* CPyCppyy::CPPMethod::Reflex(Cppyy::Reflex::RequestId_t request, Cppyy:
 }
 
 //----------------------------------------------------------------------------
-int CPyCppyy::CPPMethod::GetPriority()
+int cppjit::cpyrt::CPPMethod::GetPriority()
 {
 // To help with overload selection, methods are given a priority based on the
 // affinity of Python and C++ types. Priority only matters for methods that have
@@ -500,14 +500,14 @@ int CPyCppyy::CPPMethod::GetPriority()
 
     int priority = 0;
 
-    const size_t nArgs = Cppyy::GetMethodNumArgs(fMethod);
+    const size_t nArgs = cppjit::interop::GetMethodNumArgs(fMethod);
     for (int iarg = 0; iarg < (int)nArgs; ++iarg) {
-        const std::string aname = Cppyy::GetMethodArgTypeAsString(fMethod, iarg);
+        const std::string aname = cppjit::interop::GetMethodArgTypeAsString(fMethod, iarg);
         // FIXME: convert the string comparisons with comparison to the underlying
         // type:
-        // Cppyy::TCppType_t type = Cppyy::GetMethodArgType(fMethod, iarg);
+        // cppjit::interop::TCppType_t type = cppjit::interop::GetMethodArgType(fMethod, iarg);
 
-        if (Cppyy::IsBuiltin(aname)) {
+        if (cppjit::interop::IsBuiltin(aname)) {
         // complex type (note: double penalty: for complex and the template type)
             if (strstr(aname.c_str(), "std::complex"))
                 priority -=   10;      // prefer double, float, etc. over conversion
@@ -550,11 +550,11 @@ int CPyCppyy::CPPMethod::GetPriority()
 
         // prefer more derived classes
             const std::string& clean_name = TypeManip::clean_type(aname, false);
-            Cppyy::TCppScope_t scope = Cppyy::GetScope(clean_name);
+            cppjit::interop::TCppScope_t scope = cppjit::interop::GetScope(clean_name);
             if (scope)
-                priority += static_cast<int>(Cppyy::GetNumBasesLongestBranch(scope));
+                priority += static_cast<int>(cppjit::interop::GetNumBasesLongestBranch(scope));
 
-            if (Cppyy::IsEnumScope(scope))
+            if (cppjit::interop::IsEnumScope(scope))
                 priority -= 100;
 
         // a couple of special cases as explained above
@@ -562,7 +562,7 @@ int CPyCppyy::CPPMethod::GetPriority()
                 priority +=   150;     // needed for proper implicit conversion rules
             } else if (aname.rfind("&&", aname.size()-2) != std::string::npos) {
                 priority +=   100;     // prefer moves over other ref/ptr
-            } else if (scope && !Cppyy::IsComplete(scope)) {
+            } else if (scope && !cppjit::interop::IsComplete(scope)) {
             // class is known, but no dictionary available, 2 more cases: * and &
                 if (aname[aname.size() - 1] == '&')
                     priority += -5000;
@@ -574,31 +574,31 @@ int CPyCppyy::CPPMethod::GetPriority()
 
 // prefer methods w/o optional arguments b/c ones with optional arguments are easier to
 // select by providing the optional arguments explicitly
-    priority += ((int)Cppyy::GetMethodReqArgs(fMethod) - (int)nArgs);
+    priority += ((int)cppjit::interop::GetMethodReqArgs(fMethod) - (int)nArgs);
 
 // add a small penalty to prefer non-const methods over const ones for get/setitem
-    if (Cppyy::IsConstMethod(fMethod) && Cppyy::GetName(Cppyy::TCppScope_t(fMethod.data)) == "operator[]")
+    if (cppjit::interop::IsConstMethod(fMethod) && cppjit::interop::GetName(cppjit::interop::TCppScope_t(fMethod.data)) == "operator[]")
         priority += -10;
 
     // constructors are prefered
-    if (Cppyy::IsConstructor(fMethod))
+    if (cppjit::interop::IsConstructor(fMethod))
         priority += 100;
 
     return priority;
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::CPPMethod::IsGreedy()
+bool cppjit::cpyrt::CPPMethod::IsGreedy()
 {
 // Methods will all void*-like arguments should be sorted after template
 // instanstations, so that they don't greedily take over pointers to object.
 // GetPriority() is too heavy-handed, as it will pull in all the argument
 // types, so use this cheaper check.
-    const size_t nArgs = Cppyy::GetMethodReqArgs(fMethod);
+    const size_t nArgs = cppjit::interop::GetMethodReqArgs(fMethod);
     if (!nArgs) return false;
 
     for (int iarg = 0; iarg < (int)nArgs; ++iarg) {
-        const std::string aname = Cppyy::GetMethodArgTypeAsString(fMethod, iarg);
+        const std::string aname = cppjit::interop::GetMethodArgTypeAsString(fMethod, iarg);
         if (aname.find("void *") != 0)
             return false;
     }
@@ -607,13 +607,13 @@ bool CPyCppyy::CPPMethod::IsGreedy()
 
 
 //----------------------------------------------------------------------------
-int CPyCppyy::CPPMethod::GetMaxArgs()
+int cppjit::cpyrt::CPPMethod::GetMaxArgs()
 {
-    return (int)Cppyy::GetMethodNumArgs(fMethod);
+    return (int)cppjit::interop::GetMethodNumArgs(fMethod);
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPMethod::GetCoVarNames()
+PyObject* cppjit::cpyrt::CPPMethod::GetCoVarNames()
 {
 // Build a tuple of the argument types/names.
     int co_argcount = (int)GetMaxArgs() /* +1 for self */;
@@ -621,32 +621,32 @@ PyObject* CPyCppyy::CPPMethod::GetCoVarNames()
 // TODO: static methods need no 'self' (but is harmless otherwise)
 
     PyObject* co_varnames = PyTuple_New(co_argcount+1 /* self */);
-    PyTuple_SET_ITEM(co_varnames, 0, CPyCppyy_PyText_FromString("self"));
+    PyTuple_SET_ITEM(co_varnames, 0, cpyrt_PyText_FromString("self"));
     for (int iarg = 0; iarg < co_argcount; ++iarg) {
-        std::string argrep = Cppyy::GetMethodArgTypeAsString(fMethod, iarg);
-        const std::string& parname = Cppyy::GetMethodArgName(fMethod, iarg);
+        std::string argrep = cppjit::interop::GetMethodArgTypeAsString(fMethod, iarg);
+        const std::string& parname = cppjit::interop::GetMethodArgName(fMethod, iarg);
         if (!parname.empty()) {
             argrep += " ";
             argrep += parname;
         }
 
-        PyObject* pyspec = CPyCppyy_PyText_FromString(argrep.c_str());
+        PyObject* pyspec = cpyrt_PyText_FromString(argrep.c_str());
         PyTuple_SET_ITEM(co_varnames, iarg+1, pyspec);
     }
 
     return co_varnames;
 }
 
-PyObject* CPyCppyy::CPPMethod::GetArgDefault(int iarg, bool silent)
+PyObject* cppjit::cpyrt::CPPMethod::GetArgDefault(int iarg, bool silent)
 {
 // get and evaluate the default value (if any) of argument iarg of this method
     if (iarg >= (int)GetMaxArgs())
         return nullptr;
 
-// borrowed reference to cppyy.gbl module to use its dictionary to eval in
-    static PyObject* gbl = PyDict_GetItemString(PySys_GetObject((char*)"modules"), "cppyy.gbl");
+// borrowed reference to cppjit.gbl module to use its dictionary to eval in
+    static PyObject* gbl = PyDict_GetItemString(PySys_GetObject((char*)"modules"), "cppjit.gbl");
 
-    std::string defvalue = Cppyy::GetMethodArgDefault(fMethod, iarg);
+    std::string defvalue = cppjit::interop::GetMethodArgDefault(fMethod, iarg);
     if (!defvalue.empty()) {
         PyObject** dctptr = _PyObject_GetDictPtr(gbl);
         if (!(dctptr && *dctptr))
@@ -659,8 +659,8 @@ PyObject* CPyCppyy::CPPMethod::GetArgDefault(int iarg, bool silent)
         // try to tickle scope creation, just in case, first look in the scope where
         // the function lives, then in the global scope
             std::string possible_scope = defvalue.substr(0, defvalue.rfind('('));
-            if (!Cppyy::IsBuiltin(possible_scope)) {
-                std::string cand_scope = Cppyy::GetScopedFinalName(fScope)+"::"+possible_scope;
+            if (!cppjit::interop::IsBuiltin(possible_scope)) {
+                std::string cand_scope = cppjit::interop::GetScopedFinalName(fScope)+"::"+possible_scope;
                 scope = CreateScopeProxy(cand_scope);
                 if (!scope) {
                     PyErr_Clear();
@@ -699,7 +699,7 @@ PyObject* CPyCppyy::CPPMethod::GetArgDefault(int iarg, bool silent)
     // the error message to indicate where it's coming from)
         PyObject* pyval = nullptr;
 
-        PyObject* pycode = Py_CompileString((char*)defvalue.c_str(), "cppyy_default_compiler", Py_eval_input);
+        PyObject* pycode = Py_CompileString((char*)defvalue.c_str(), "cppjit_default_compiler", Py_eval_input);
         if (pycode) {
             pyval = PyEval_EvalCode(pycode, gdct, gdct);
             Py_DECREF(pycode);
@@ -707,25 +707,25 @@ PyObject* CPyCppyy::CPPMethod::GetArgDefault(int iarg, bool silent)
 
         if (!pyval && PyErr_Occurred() && silent) {
             PyErr_Clear();
-            pyval = CPyCppyy_PyText_FromString(defvalue.c_str());    // allows continuation, but is likely to fail
+            pyval = cpyrt_PyText_FromString(defvalue.c_str());    // allows continuation, but is likely to fail
         }
 
         Py_XDECREF(scope);
         return pyval;        // may be nullptr
     }
 
-    PyErr_Format(PyExc_TypeError, "Could not construct default value for: %s", Cppyy::GetMethodArgName(fMethod, iarg).c_str());
+    PyErr_Format(PyExc_TypeError, "Could not construct default value for: %s", cppjit::interop::GetMethodArgName(fMethod, iarg).c_str());
     return nullptr;
 }
 
 
-bool CPyCppyy::CPPMethod::IsConst() {
-    return Cppyy::IsConstMethod(GetMethod());
+bool cppjit::cpyrt::CPPMethod::IsConst() {
+    return cppjit::interop::IsConstMethod(GetMethod());
 }
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPMethod::GetScopeProxy()
+PyObject* cppjit::cpyrt::CPPMethod::GetScopeProxy()
 {
 // Get or build the scope of this method.
     return CreateScopeProxy(fScope);
@@ -733,18 +733,18 @@ PyObject* CPyCppyy::CPPMethod::GetScopeProxy()
 
 
 //----------------------------------------------------------------------------
-Cppyy::TCppFuncAddr_t CPyCppyy::CPPMethod::GetFunctionAddress()
+cppjit::interop::TCppFuncAddr_t cppjit::cpyrt::CPPMethod::GetFunctionAddress()
 {
 // Return the C++ pointer of this function
-    return Cppyy::GetFunctionAddress(fMethod, false /* don't check fast path envar */);
+    return cppjit::interop::GetFunctionAddress(fMethod, false /* don't check fast path envar */);
 }
 
 //----------------------------------------------------------------------------
-int CPyCppyy::CPPMethod::GetArgMatchScore(PyObject* args_tuple)
+int cppjit::cpyrt::CPPMethod::GetArgMatchScore(PyObject* args_tuple)
 {
     Py_ssize_t n = PyTuple_Size(args_tuple);
 
-    int req_args = Cppyy::GetMethodReqArgs(fMethod);
+    int req_args = cppjit::interop::GetMethodReqArgs(fMethod);
 
     // Not enough arguments supplied: no match
     if (req_args > n)
@@ -753,13 +753,13 @@ int CPyCppyy::CPPMethod::GetArgMatchScore(PyObject* args_tuple)
     size_t score = 0;
     for (int i = 0; i < n; i++) {
         PyObject *pItem = PyTuple_GetItem(args_tuple, i);
-        if(!CPyCppyy_PyText_Check(pItem)) {
+        if(!cpyrt_PyText_Check(pItem)) {
             PyErr_SetString(PyExc_TypeError, "argument types should be in string format");
             return INT_MAX;
         }
-        std::string req_type(CPyCppyy_PyText_AsString(pItem));
+        std::string req_type(cpyrt_PyText_AsString(pItem));
 
-        size_t arg_score = Cppyy::CompareMethodArgType(fMethod, i, req_type);
+        size_t arg_score = cppjit::interop::CompareMethodArgType(fMethod, i, req_type);
 
         // Method is not compatible if even one argument does not match
         if (arg_score >= 10) {
@@ -774,7 +774,7 @@ int CPyCppyy::CPPMethod::GetArgMatchScore(PyObject* args_tuple)
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::CPPMethod::Initialize(CallContext* ctxt)
+bool cppjit::cpyrt::CPPMethod::Initialize(CallContext* ctxt)
 {
 // done if cache is already setup
     if (fArgsRequired != -1)
@@ -787,16 +787,16 @@ bool CPyCppyy::CPPMethod::Initialize(CallContext* ctxt)
         return false;
 
 // minimum number of arguments when calling
-    fArgsRequired = (int)((bool)fMethod == true ? Cppyy::GetMethodReqArgs(fMethod) : 0);
+    fArgsRequired = (int)((bool)fMethod == true ? cppjit::interop::GetMethodReqArgs(fMethod) : 0);
 
     return true;
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::CPPMethod::ProcessKwds(PyObject* self_in, PyCallArgs& cargs)
+bool cppjit::cpyrt::CPPMethod::ProcessKwds(PyObject* self_in, PyCallArgs& cargs)
 {
     if (!PyTuple_CheckExact(cargs.fKwds)) {
-        SetPyError_(CPyCppyy_PyText_FromString("received unknown keyword names object"));
+        SetPyError_(cpyrt_PyText_FromString("received unknown keyword names object"));
         return false;
     }
     Py_ssize_t nKeys = PyTuple_GET_SIZE(cargs.fKwds);
@@ -806,11 +806,11 @@ bool CPyCppyy::CPPMethod::ProcessKwds(PyObject* self_in, PyCallArgs& cargs)
 
     if (!fArgIndices) {
         fArgIndices = new std::unordered_map<std::string, int>{};
-        for (int iarg = 0; iarg < (int)Cppyy::GetMethodNumArgs(fMethod); ++iarg)
-            (*fArgIndices)[Cppyy::GetMethodArgName(fMethod, iarg)] = iarg;
+        for (int iarg = 0; iarg < (int)cppjit::interop::GetMethodNumArgs(fMethod); ++iarg)
+            (*fArgIndices)[cppjit::interop::GetMethodArgName(fMethod, iarg)] = iarg;
     }
 
-    Py_ssize_t nArgs = CPyCppyy_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf) + (self_in ? 1 : 0);
+    Py_ssize_t nArgs = cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf) + (self_in ? 1 : 0);
     if (!VerifyArgCount_(nArgs+nKeys))
         return false;
 
@@ -820,18 +820,18 @@ bool CPyCppyy::CPPMethod::ProcessKwds(PyObject* self_in, PyCallArgs& cargs)
     PyObject *key, *value;
     Py_ssize_t maxpos = -1;
 
-    Py_ssize_t npos_args = CPyCppyy_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
+    Py_ssize_t npos_args = cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf);
     for (Py_ssize_t ikey = 0; ikey < nKeys; ++ikey) {
         key = PyTuple_GET_ITEM(cargs.fKwds, ikey);
         value = cargs.fArgs[npos_args+ikey];
-        const char* ckey = CPyCppyy_PyText_AsStringChecked(key);
+        const char* ckey = cpyrt_PyText_AsStringChecked(key);
         if (!ckey)
             return false;
 
         auto p = fArgIndices->find(ckey);
         if (p == fArgIndices->end()) {
-            SetPyError_(CPyCppyy_PyText_FromFormat("%s::%s got an unexpected keyword argument \'%s\'",
-                Cppyy::GetFinalName(fScope).c_str(), Cppyy::GetName(Cppyy::TCppScope_t(fMethod.data)).c_str(), ckey));
+            SetPyError_(cpyrt_PyText_FromFormat("%s::%s got an unexpected keyword argument \'%s\'",
+                cppjit::interop::GetFinalName(fScope).c_str(), cppjit::interop::GetName(cppjit::interop::TCppScope_t(fMethod.data)).c_str(), ckey));
             return false;
         }
 
@@ -841,32 +841,32 @@ bool CPyCppyy::CPPMethod::ProcessKwds(PyObject* self_in, PyCallArgs& cargs)
 
 // if maxpos < nArgs, it will be detected & reported as a duplicate below
     Py_ssize_t maxargs = maxpos + 1;
-    CPyCppyy_PyArgs_t newArgs = CPyCppyy_PyArgs_New(maxargs);
+    cpyrt_PyArgs_t newArgs = cpyrt_PyArgs_New(maxargs);
 
 // set all values to zero to be able to check them later (this also guarantees normal
 // cleanup by the tuple deallocation)
     for (Py_ssize_t i = 0; i < maxargs; ++i)
-        CPyCppyy_PyArgs_SET_ITEM(newArgs, i, nullptr);
+        cpyrt_PyArgs_SET_ITEM(newArgs, i, nullptr);
 
 // fill out the positional arguments
     Py_ssize_t start = 0;
     if (self_in) {
         Py_INCREF(self_in);
-        CPyCppyy_PyArgs_SET_ITEM(newArgs, 0, self_in);
+        cpyrt_PyArgs_SET_ITEM(newArgs, 0, self_in);
         start = 1;
     }
 
     for (Py_ssize_t i = start; i < nArgs; ++i) {
         if (vArgs[i]) {
-            SetPyError_(CPyCppyy_PyText_FromFormat("%s::%s got multiple values for argument %d",
-                Cppyy::GetFinalName(fScope).c_str(), Cppyy::GetName(Cppyy::TCppScope_t(fMethod.data)).c_str(), (int)i+1));
-            CPyCppyy_PyArgs_DEL(newArgs);
+            SetPyError_(cpyrt_PyText_FromFormat("%s::%s got multiple values for argument %d",
+                cppjit::interop::GetFinalName(fScope).c_str(), cppjit::interop::GetName(cppjit::interop::TCppScope_t(fMethod.data)).c_str(), (int)i+1));
+            cpyrt_PyArgs_DEL(newArgs);
             return false;
         }
 
-        PyObject* item = CPyCppyy_PyArgs_GET_ITEM(cargs.fArgs, i);
+        PyObject* item = cpyrt_PyArgs_GET_ITEM(cargs.fArgs, i);
         Py_INCREF(item);
-        CPyCppyy_PyArgs_SET_ITEM(newArgs, i, item);
+        cpyrt_PyArgs_SET_ITEM(newArgs, i, item);
     }
 
 // fill out the keyword arguments
@@ -874,22 +874,22 @@ bool CPyCppyy::CPPMethod::ProcessKwds(PyObject* self_in, PyCallArgs& cargs)
         PyObject* item = vArgs[i];
         if (item) {
             Py_INCREF(item);
-            CPyCppyy_PyArgs_SET_ITEM(newArgs, i, item);
+            cpyrt_PyArgs_SET_ITEM(newArgs, i, item);
         } else {
         // try retrieving the default
             item = GetArgDefault((int)i, false /* i.e. not silent */);
             if (!item) {
-                CPyCppyy_PyArgs_DEL(newArgs);
+                cpyrt_PyArgs_DEL(newArgs);
                 return false;
             }
-            CPyCppyy_PyArgs_SET_ITEM(newArgs, i, item);
+            cpyrt_PyArgs_SET_ITEM(newArgs, i, item);
         }
     }
 
     if (cargs.fFlags & PyCallArgs::kDoFree) {
         if (cargs.fFlags & PyCallArgs::kIsOffset)
             cargs.fArgs -= 1;
-       CPyCppyy_PyArgs_DEL(cargs.fArgs);
+       cpyrt_PyArgs_DEL(cargs.fArgs);
     }
 
     cargs.fArgs = newArgs;
@@ -900,7 +900,7 @@ bool CPyCppyy::CPPMethod::ProcessKwds(PyObject* self_in, PyCallArgs& cargs)
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::CPPMethod::ProcessArgs(PyCallArgs& cargs)
+bool cppjit::cpyrt::CPPMethod::ProcessArgs(PyCallArgs& cargs)
 {
 // verify existence of self, return if ok
     if (cargs.fSelf) {
@@ -909,16 +909,16 @@ bool CPyCppyy::CPPMethod::ProcessArgs(PyCallArgs& cargs)
     }
 
 // otherwise, check for a suitable 'self' in args and update accordingly
-    if (CPyCppyy_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf) != 0) {
-        CPPInstance* pyobj = (CPPInstance*)CPyCppyy_PyArgs_GET_ITEM(cargs.fArgs, 0);
+    if (cpyrt_PyArgs_GET_SIZE(cargs.fArgs, cargs.fNArgsf) != 0) {
+        CPPInstance* pyobj = (CPPInstance*)cpyrt_PyArgs_GET_ITEM(cargs.fArgs, 0);
 
-    // demand CPyCppyy object, and an argument that may match down the road
+    // demand cpyrt object, and an argument that may match down the road
         if (CPPInstance_Check(pyobj)) {
-            Cppyy::TCppScope_t oisa = pyobj->ObjectIsA();
-            if (fScope == Cppyy::GetGlobalScope() ||         // free global
+            cppjit::interop::TCppScope_t oisa = pyobj->ObjectIsA();
+            if (fScope == cppjit::interop::GetGlobalScope() ||         // free global
                 oisa == nullptr ||                                    // null pointer or ctor call
                 oisa == fScope ||                               // matching types
-                Cppyy::IsSubclass(oisa, fScope)) {               // id.
+                cppjit::interop::IsSubclass(oisa, fScope)) {               // id.
 
             // reset self
                 Py_INCREF(pyobj);      // corresponding Py_DECREF is in CPPOverload
@@ -938,17 +938,17 @@ bool CPyCppyy::CPPMethod::ProcessArgs(PyCallArgs& cargs)
     }
 
 // no self, set error and lament
-    SetPyError_(CPyCppyy_PyText_FromFormat(
+    SetPyError_(cpyrt_PyText_FromFormat(
         "unbound method %s::%s must be called with a %s instance as first argument",
-        Cppyy::GetFinalName(fScope).c_str(), Cppyy::GetName(Cppyy::TCppScope_t(fMethod.data)).c_str(),
-        Cppyy::GetFinalName(fScope).c_str()));
+        cppjit::interop::GetFinalName(fScope).c_str(), cppjit::interop::GetName(cppjit::interop::TCppScope_t(fMethod.data)).c_str(),
+        cppjit::interop::GetFinalName(fScope).c_str()));
     return false;
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::CPPMethod::ConvertAndSetArgs(CPyCppyy_PyArgs_t args, size_t nargsf, CallContext* ctxt)
+bool cppjit::cpyrt::CPPMethod::ConvertAndSetArgs(cpyrt_PyArgs_t args, size_t nargsf, CallContext* ctxt)
 {
-    Py_ssize_t argc = CPyCppyy_PyArgs_GET_SIZE(args, nargsf);
+    Py_ssize_t argc = cpyrt_PyArgs_GET_SIZE(args, nargsf);
     if (!VerifyArgCount_(argc))
         return false;
 
@@ -962,8 +962,8 @@ bool CPyCppyy::CPPMethod::ConvertAndSetArgs(CPyCppyy_PyArgs_t args, size_t nargs
     bool isOK = true;
     Parameter* cppArgs = ctxt->GetArgs(argc);
     for (int i = 0; i < (int)argc; ++i) {
-        if (!fConverters[i]->SetArg(CPyCppyy_PyArgs_GET_ITEM(args, i), cppArgs[i], ctxt)) {
-            SetPyError_(CPyCppyy_PyText_FromFormat("could not convert argument %d: %s", i+1, fConverters[i]->GetFailureMsg().c_str()));
+        if (!fConverters[i]->SetArg(cpyrt_PyArgs_GET_ITEM(args, i), cppArgs[i], ctxt)) {
+            SetPyError_(cpyrt_PyText_FromFormat("could not convert argument %d: %s", i+1, fConverters[i]->GetFailureMsg().c_str()));
             isOK = false;
             break;
         }
@@ -973,7 +973,7 @@ bool CPyCppyy::CPPMethod::ConvertAndSetArgs(CPyCppyy_PyArgs_t args, size_t nargs
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPMethod::Execute(void* self, ptrdiff_t offset, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CPPMethod::Execute(void* self, ptrdiff_t offset, CallContext* ctxt)
 {
 // call the interface method
     PyObject* result = 0;
@@ -994,8 +994,8 @@ PyObject* CPyCppyy::CPPMethod::Execute(void* self, ptrdiff_t offset, CallContext
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPMethod::Call(CPPInstance*& self,
-    CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CPPMethod::Call(CPPInstance*& self,
+    cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
 {
 // setup as necessary
     if (fArgsRequired == -1 && !Initialize(ctxt))
@@ -1011,7 +1011,7 @@ PyObject* CPyCppyy::CPPMethod::Call(CPPInstance*& self,
         ctxt->fPyContext = (PyObject*)cargs.fSelf;    // no Py_INCREF as no ownership
 
 // translate the arguments
-    if (fArgsRequired || CPyCppyy_PyArgs_GET_SIZE(args, cargs.fNArgsf)) {
+    if (fArgsRequired || cpyrt_PyArgs_GET_SIZE(args, cargs.fNArgsf)) {
         if (!ConvertAndSetArgs(cargs.fArgs, cargs.fNArgsf, ctxt))
             return nullptr;
     }
@@ -1026,20 +1026,20 @@ PyObject* CPyCppyy::CPPMethod::Call(CPPInstance*& self,
     }
 
 // get its class
-    Cppyy::TCppScope_t derived = self->ObjectIsA();
+    cppjit::interop::TCppScope_t derived = self->ObjectIsA();
 
 // calculate offset: the generated wrapper casts 'this' to the method's actual
 // declaring class, which may differ from fScope. In particular, a method
 // brought into fScope through a using-declaration (e.g. `using Base::meth;`)
 // is still declared in the base, so 'this' has to be adjusted to that base's
 // subobject. Using fScope here would yield a zero offset and corrupt memory.
-    Cppyy::TCppScope_t declaring = Cppyy::GetParentScope(Cppyy::TCppScope_t(fMethod.data));
+    cppjit::interop::TCppScope_t declaring = cppjit::interop::GetParentScope(cppjit::interop::TCppScope_t(fMethod.data));
     if (!declaring)
         declaring = fScope;
 
     ptrdiff_t offset = 0;
     if (derived && derived != declaring)
-        offset = Cppyy::GetBaseOffset(derived, declaring, object, 1 /* up-cast */);
+        offset = cppjit::interop::GetBaseOffset(derived, declaring, object, 1 /* up-cast */);
 
 // actual call; recycle self instead of returning new object for same address objects
     CPPInstance* pyobj = (CPPInstance*)Execute(object, offset, ctxt);
@@ -1055,10 +1055,10 @@ PyObject* CPyCppyy::CPPMethod::Call(CPPInstance*& self,
 }
 
 //- protected members --------------------------------------------------------
-PyObject* CPyCppyy::CPPMethod::GetSignature(bool fa)
+PyObject* cppjit::cpyrt::CPPMethod::GetSignature(bool fa)
 {
 // construct python string from the method's signature
-    return CPyCppyy_PyText_FromString(GetSignatureString(fa).c_str());
+    return cpyrt_PyText_FromString(GetSignatureString(fa).c_str());
 }
 
 /**
@@ -1072,15 +1072,15 @@ PyObject* CPyCppyy::CPPMethod::GetSignature(bool fa)
  *
  * ('a', 'b', 'c')
  */
-PyObject *CPyCppyy::CPPMethod::GetSignatureNames()
+PyObject *cppjit::cpyrt::CPPMethod::GetSignatureNames()
 {
    // Build a tuple of the argument names for this signature.
    int argcount = GetMaxArgs();
    PyObject *signature_names = PyTuple_New(argcount);
 
    for (int iarg = 0; iarg < argcount; ++iarg) {
-      const std::string &argname_cpp = Cppyy::GetMethodArgName(fMethod, iarg);
-      PyObject *argname_py = CPyCppyy_PyText_FromString(argname_cpp.c_str());
+      const std::string &argname_cpp = cppjit::interop::GetMethodArgName(fMethod, iarg);
+      PyObject *argname_py = cpyrt_PyText_FromString(argname_cpp.c_str());
       PyTuple_SET_ITEM(signature_names, iarg, argname_py);
    }
 
@@ -1100,33 +1100,33 @@ PyObject *CPyCppyy::CPPMethod::GetSignatureNames()
  *
  * {'input_types': ('int', 'float', 'double'), 'return_type': 'double'}
  */
-PyObject *CPyCppyy::CPPMethod::GetSignatureTypes()
+PyObject *cppjit::cpyrt::CPPMethod::GetSignatureTypes()
 {
 
    PyObject *signature_types_dict = PyDict_New();
 
    // Insert the return type first
    std::string return_type = GetReturnTypeName();
-   PyObject *return_type_py = CPyCppyy_PyText_FromString(return_type.c_str());
-   PyDict_SetItem(signature_types_dict, CPyCppyy_PyText_FromString("return_type"), return_type_py);
+   PyObject *return_type_py = cpyrt_PyText_FromString(return_type.c_str());
+   PyDict_SetItem(signature_types_dict, cpyrt_PyText_FromString("return_type"), return_type_py);
 
    // Build a tuple of the argument types for this signature.
    int argcount = GetMaxArgs();
    PyObject *parameter_types = PyTuple_New(argcount);
 
    for (int iarg = 0; iarg < argcount; ++iarg) {
-      const std::string &argtype_cpp = Cppyy::GetMethodArgTypeAsString(fMethod, iarg);
-      PyObject *argtype_py = CPyCppyy_PyText_FromString(argtype_cpp.c_str());
+      const std::string &argtype_cpp = cppjit::interop::GetMethodArgTypeAsString(fMethod, iarg);
+      PyObject *argtype_py = cpyrt_PyText_FromString(argtype_cpp.c_str());
       PyTuple_SET_ITEM(parameter_types, iarg, argtype_py);
    }
 
-   PyDict_SetItem(signature_types_dict, CPyCppyy_PyText_FromString("input_types"), parameter_types);
+   PyDict_SetItem(signature_types_dict, cpyrt_PyText_FromString("input_types"), parameter_types);
 
    return signature_types_dict;
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::CPPMethod::GetReturnTypeName()
+std::string cppjit::cpyrt::CPPMethod::GetReturnTypeName()
 {
-    return Cppyy::GetMethodReturnTypeAsString(fMethod);
+    return cppjit::interop::GetMethodReturnTypeAsString(fMethod);
 }
diff --git a/src/CPyCppyy/src/CPPMethod.h b/src/cpyrt/CPPMethod.h
similarity index 74%
rename from src/CPyCppyy/src/CPPMethod.h
rename to src/cpyrt/CPPMethod.h
index e13a8da..44222b6 100644
--- a/src/CPyCppyy/src/CPPMethod.h
+++ b/src/cpyrt/CPPMethod.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_CPPMETHOD_H
-#define CPYCPPYY_CPPMETHOD_H
+#ifndef CPYRT_CPPMETHOD_H
+#define CPYRT_CPPMETHOD_H
 
 // Bindings
 #include "PyCallable.h"
@@ -10,14 +10,14 @@
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class Executor;
 class Converter;
 
 class PyCallArgs {
 public:
-    PyCallArgs(CPPInstance*& self, CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds)
+    PyCallArgs(CPPInstance*& self, cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds)
         : fSelf(self), fArgs(args), fNArgsf(nargsf), fKwds(kwds), fFlags(kNone) {}
     ~PyCallArgs();
 
@@ -32,7 +32,7 @@ class PyCallArgs {
 
 public:
     CPPInstance*&     fSelf;
-    CPyCppyy_PyArgs_t fArgs;
+    cpyrt_PyArgs_t fArgs;
     size_t            fNArgsf;
     PyObject*         fKwds;
     int               fFlags;
@@ -40,7 +40,7 @@ class PyCallArgs {
 
 class CPPMethod : public PyCallable {
 public:
-    CPPMethod(Cppyy::TCppScope_t scope, Cppyy::TCppMethod_t method);
+    CPPMethod(cppjit::interop::TCppScope_t scope, cppjit::interop::TCppMethod_t method);
     CPPMethod(const CPPMethod&);
     CPPMethod& operator=(const CPPMethod&);
     virtual ~CPPMethod();
@@ -51,8 +51,8 @@ class CPPMethod : public PyCallable {
     PyObject* GetSignatureTypes() override;
     PyObject* GetPrototype(bool show_formalargs = true) override;
     PyObject* GetTypeName() override;
-    PyObject* Reflex(Cppyy::Reflex::RequestId_t request,
-                             Cppyy::Reflex::FormatId_t = Cppyy::Reflex::OPTIMAL) override;
+    PyObject* Reflex(cppjit::interop::Reflex::RequestId_t request,
+                             cppjit::interop::Reflex::FormatId_t = cppjit::interop::Reflex::OPTIMAL) override;
 
     int       GetPriority() override;
     bool      IsGreedy() override;
@@ -63,7 +63,7 @@ class CPPMethod : public PyCallable {
     bool      IsConst() override;
 
     PyObject* GetScopeProxy() override;
-    Cppyy::TCppFuncAddr_t GetFunctionAddress() override;
+    cppjit::interop::TCppFuncAddr_t GetFunctionAddress() override;
 
     PyCallable* Clone() override { return new CPPMethod(*this); }
 
@@ -71,18 +71,18 @@ class CPPMethod : public PyCallable {
 
 public:
     PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
 
 protected:
     virtual bool ProcessArgs(PyCallArgs& args);
 
     bool Initialize(CallContext* ctxt = nullptr);
     bool ProcessKwds(PyObject* self_in, PyCallArgs& args);
-    bool ConvertAndSetArgs(CPyCppyy_PyArgs_t, size_t nargsf, CallContext* ctxt = nullptr);
+    bool ConvertAndSetArgs(cpyrt_PyArgs_t, size_t nargsf, CallContext* ctxt = nullptr);
     PyObject* Execute(void* self, ptrdiff_t offset, CallContext* ctxt = nullptr);
 
-    Cppyy::TCppMethod_t GetMethod()   { return fMethod; }
-    Cppyy::TCppScope_t  GetScope()    { return fScope; }
+    cppjit::interop::TCppMethod_t GetMethod()   { return fMethod; }
+    cppjit::interop::TCppScope_t  GetScope()    { return fScope; }
     Executor*           GetExecutor() { return fExecutor; }
     std::string         GetSignatureString(bool show_formalargs = true);
     std::string         GetReturnTypeName();
@@ -103,8 +103,8 @@ class CPPMethod : public PyCallable {
 
 private:
 // representation
-    Cppyy::TCppMethod_t fMethod;
-    Cppyy::TCppScope_t  fScope;
+    cppjit::interop::TCppMethod_t fMethod;
+    cppjit::interop::TCppScope_t  fScope;
     Executor*           fExecutor;
 
 // call dispatch buffers
@@ -116,6 +116,6 @@ class CPPMethod : public PyCallable {
     int fArgsRequired;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPMETHOD_H
+#endif // !CPYRT_CPPMETHOD_H
diff --git a/src/CPyCppyy/src/CPPOperator.cxx b/src/cpyrt/CPPOperator.cxx
similarity index 68%
rename from src/CPyCppyy/src/CPPOperator.cxx
rename to src/cpyrt/CPPOperator.cxx
index bf2aa60..cbb2de6 100644
--- a/src/CPyCppyy/src/CPPOperator.cxx
+++ b/src/cpyrt/CPPOperator.cxx
@@ -1,19 +1,19 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPOperator.h"
 #include "CPPInstance.h"
 #include "Utility.h"
 
 
 //- constructor --------------------------------------------------------------
-CPyCppyy::CPPOperator::CPPOperator(
-    Cppyy::TCppScope_t scope, Cppyy::TCppMethod_t method, const std::string& name)
+cppjit::cpyrt::CPPOperator::CPPOperator(
+    cppjit::interop::TCppScope_t scope, cppjit::interop::TCppMethod_t method, const std::string& name)
         : CPPMethod(scope, method)
 {
 // a bit silly but doing it this way allows decoupling the initialization order
     if (name == "__mul__")
         fStub = CPPInstance_Type.tp_as_number->nb_multiply;
-    else if (name == CPPYY__div__)
+    else if (name == CPPJIT__div__)
         fStub = CPPInstance_Type.tp_as_number->nb_true_divide;
     else if (name == "__add__")
         fStub = CPPInstance_Type.tp_as_number->nb_add;
@@ -24,8 +24,8 @@ CPyCppyy::CPPOperator::CPPOperator(
 }
 
 //-----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPOperator::Call(CPPInstance*& self,
-    CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CPPOperator::Call(CPPInstance*& self,
+    cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt)
 {
 // some operators can be a mix of global and class overloads; this method will
 // first try class overloads (the existence of this method means that such were
@@ -37,21 +37,21 @@ PyObject* CPyCppyy::CPPOperator::Call(CPPInstance*& self,
         return result;
 
     Py_ssize_t idx_other = 0;
-    if (CPyCppyy_PyArgs_GET_SIZE(args, nargsf) != 1) {
-        if ((CPyCppyy_PyArgs_GET_SIZE(args, nargsf) == 2 && CPyCppyy_PyArgs_GET_ITEM(args, 0) == (PyObject*)self))
+    if (cpyrt_PyArgs_GET_SIZE(args, nargsf) != 1) {
+        if ((cpyrt_PyArgs_GET_SIZE(args, nargsf) == 2 && cpyrt_PyArgs_GET_ITEM(args, 0) == (PyObject*)self))
             idx_other = 1;
         else
         return result;
     }
 
 // fetch the current error, resetting the error buffer
-    auto error = CPyCppyy::Utility::FetchPyError();
+    auto error = cppjit::cpyrt::Utility::FetchPyError();
 
-    result = fStub((PyObject*)self, CPyCppyy_PyArgs_GET_ITEM(args, idx_other));
+    result = fStub((PyObject*)self, cpyrt_PyArgs_GET_ITEM(args, idx_other));
 
 // if there was still a problem, restore the Python error buffer
     if (!result) {
-        CPyCppyy::Utility::RestorePyError(error);
+        cppjit::cpyrt::Utility::RestorePyError(error);
     }
 
     return result;
diff --git a/src/cpyrt/CPPOperator.h b/src/cpyrt/CPPOperator.h
new file mode 100644
index 0000000..e46df5b
--- /dev/null
+++ b/src/cpyrt/CPPOperator.h
@@ -0,0 +1,28 @@
+#ifndef CPYRT_CPPOPERATOR_H
+#define CPYRT_CPPOPERATOR_H
+
+// Bindings
+#include "CPPMethod.h"
+
+// Standard
+#include <string>
+
+
+namespace cppjit::cpyrt {
+
+class CPPOperator : public CPPMethod {
+public:
+    CPPOperator(cppjit::interop::TCppScope_t scope, cppjit::interop::TCppMethod_t method, const std::string& name);
+
+public:
+    PyCallable* Clone() override { return new CPPOperator(*this); }
+    PyObject* Call(CPPInstance*& self,
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) override;
+
+private:
+    binaryfunc fStub;
+};
+
+} // namespace cppjit::cpyrt
+
+#endif // !CPYRT_CPPOPERATOR_H
diff --git a/src/CPyCppyy/src/CPPOverload.cxx b/src/cpyrt/CPPOverload.cxx
similarity index 92%
rename from src/CPyCppyy/src/CPPOverload.cxx
rename to src/cpyrt/CPPOverload.cxx
index b4fb1da..e55993b 100644
--- a/src/CPyCppyy/src/CPPOverload.cxx
+++ b/src/cpyrt/CPPOverload.cxx
@@ -1,6 +1,6 @@
 // Bindings
-#include "CPyCppyy.h"
-#include "CPyCppyy/Reflex.h"
+#include "cpyrt.h"
+#include "cpyrt/Reflex.h"
 #include "structmember.h"    // from Python
 #if PY_VERSION_HEX <  0x030b0000
 #include "code.h"            // from Python
@@ -21,7 +21,7 @@
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 namespace {
 
@@ -56,7 +56,7 @@ class TPythonCallback : public PyCallable {
     }
 
     PyObject* GetSignature(bool /*show_formalargs*/ = true) override {
-        return CPyCppyy_PyText_FromString("*args, **kwargs");
+        return cpyrt_PyText_FromString("*args, **kwargs");
     }
     PyObject* GetSignatureNames() override {
         return PyTuple_New(0);
@@ -65,7 +65,7 @@ class TPythonCallback : public PyCallable {
         return PyTuple_New(0);
     }
     PyObject* GetPrototype(bool /*show_formalargs*/ = true) override {
-        return CPyCppyy_PyText_FromString("<callback>");
+        return cpyrt_PyText_FromString("<callback>");
     }
     PyObject* GetDocString() override {
         if (PyObject_HasAttrString(fCallable, "__doc__")) {
@@ -90,14 +90,14 @@ class TPythonCallback : public PyCallable {
         Py_RETURN_NONE;
     }
 
-    Cppyy::TCppFuncAddr_t GetFunctionAddress() override {
-        return (Cppyy::TCppFuncAddr_t)nullptr;
+    cppjit::interop::TCppFuncAddr_t GetFunctionAddress() override {
+        return (cppjit::interop::TCppFuncAddr_t)nullptr;
     }
 
     PyCallable* Clone() override { return new TPythonCallback(*this); }
 
     PyObject* Call(CPPInstance*& self,
-            CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* /* ctxt = 0 */) override {
+            cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* /* ctxt = 0 */) override {
 
         if (self) {
             if (nargsf & PY_VECTORCALL_ARGUMENTS_OFFSET) {      // mutation allowed?
@@ -119,7 +119,7 @@ class TPythonCallback : public PyCallable {
             nargsf += 1;
         }
 
-        PyObject* result = CPyCppyy_PyObject_Call(fCallable, args, nargsf, kwds);
+        PyObject* result = cpyrt_PyObject_Call(fCallable, args, nargsf, kwds);
         if (self) {
             if (nargsf & PY_VECTORCALL_ARGUMENTS_OFFSET)
                 std::swap(((PyObject**)args-1)[0], (PyObject*&)self);
@@ -189,7 +189,7 @@ static inline PyObject* HandleReturn(
                             ll_action = 3;
                         else {
                             ptrdiff_t offset = (ptrdiff_t)cppres->GetObject() - (ptrdiff_t)im_self->GetObject();
-                            if (0 <= offset && offset < (ptrdiff_t)Cppyy::SizeOf(im_self->ObjectIsA()))
+                            if (0 <= offset && offset < (ptrdiff_t)cppjit::interop::SizeOf(im_self->ObjectIsA()))
                                  ll_action = 4;
                         }
                     }
@@ -214,10 +214,10 @@ static inline PyObject* HandleReturn(
 }
 
 
-//= CPyCppyy method proxy object behaviour ===================================
+//= cpyrt method proxy object behaviour ===================================
 static PyObject* mp_name(CPPOverload* pymeth, void*)
 {
-    return CPyCppyy_PyText_FromString(pymeth->GetName().c_str());
+    return cpyrt_PyText_FromString(pymeth->GetName().c_str());
 }
 
 //----------------------------------------------------------------------------
@@ -249,10 +249,10 @@ static PyObject* mp_doc(CPPOverload* pymeth, void*)
         return doc;
 
 // overloaded method
-    PyObject* separator = CPyCppyy_PyText_FromString("\n");
+    PyObject* separator = cpyrt_PyText_FromString("\n");
     for (CPPOverload::Methods_t::size_type i = 1; i < nMethods; ++i) {
-        CPyCppyy_PyText_Append(&doc, separator);
-        CPyCppyy_PyText_AppendAndDel(&doc, methods[i]->GetDocString());
+        cpyrt_PyText_Append(&doc, separator);
+        cpyrt_PyText_AppendAndDel(&doc, methods[i]->GetDocString());
     }
     Py_DECREF(separator);
 
@@ -410,9 +410,9 @@ static PyObject* mp_func_defaults(CPPOverload* pymeth, void*)
 //----------------------------------------------------------------------------
 static PyObject* mp_func_globals(CPPOverload* /* pymeth */, void*)
 {
-// Return this function's global dict (hard-wired to be the cppyy module); used
+// Return this function's global dict (hard-wired to be the cppjit module); used
 // for lookup of names from co_code indexing into co_names.
-    PyObject* pyglobal = PyModule_GetDict(PyImport_AddModule((char*)"cppyy"));
+    PyObject* pyglobal = PyModule_GetDict(PyImport_AddModule((char*)"cppjit"));
     Py_XINCREF(pyglobal);
     return pyglobal;
 }
@@ -489,7 +489,7 @@ static int mp_setmempolicy(CPPOverload* pymeth, PyObject* value, void*)
 
 
 //----------------------------------------------------------------------------
-#define CPPYY_BOOLEAN_PROPERTY(name, flag, label)                            \
+#define CPPJIT_BOOLEAN_PROPERTY(name, flag, label)                            \
 static PyObject* mp_get##name(CPPOverload* pymeth, void*) {                  \
     if (pymeth->fMethodInfo->fFlags & flag) {                                \
         Py_RETURN_TRUE;                                                      \
@@ -501,24 +501,24 @@ static int mp_set##name(CPPOverload* pymeth, PyObject* value, void*) {       \
     return set_flag(pymeth, value, flag, label);                             \
 }
 
-CPPYY_BOOLEAN_PROPERTY(lifeline, CallContext::kSetLifeLine, "__set_lifeline__")
-CPPYY_BOOLEAN_PROPERTY(threaded, CallContext::kReleaseGIL,  "__release_gil__")
-CPPYY_BOOLEAN_PROPERTY(useffi,   CallContext::kUseFFI,      "__useffi__")
-CPPYY_BOOLEAN_PROPERTY(sig2exc,  CallContext::kProtected,   "__sig2exc__")
+CPPJIT_BOOLEAN_PROPERTY(lifeline, CallContext::kSetLifeLine, "__set_lifeline__")
+CPPJIT_BOOLEAN_PROPERTY(threaded, CallContext::kReleaseGIL,  "__release_gil__")
+CPPJIT_BOOLEAN_PROPERTY(useffi,   CallContext::kUseFFI,      "__useffi__")
+CPPJIT_BOOLEAN_PROPERTY(sig2exc,  CallContext::kProtected,   "__sig2exc__")
 
 static PyObject* mp_getcppname(CPPOverload* pymeth, void*)
 {
     if ((void*)pymeth == (void*)&CPPOverload_Type)
-        return CPyCppyy_PyText_FromString("CPPOverload_Type");
+        return cpyrt_PyText_FromString("CPPOverload_Type");
 
     auto& methods = pymeth->fMethodInfo->fMethods;
     if (methods.empty())
-        return CPyCppyy_PyText_FromString("void (*)()");   // debatable
+        return cpyrt_PyText_FromString("void (*)()");   // debatable
 
     if (methods.size() == 1)
         return methods[0]->GetTypeName();
 
-    return CPyCppyy_PyText_FromString("void* (*)(...)");   // id.
+    return cpyrt_PyText_FromString("void* (*)(...)");   // id.
 }
 
 
@@ -565,7 +565,7 @@ static PyGetSetDef mp_getset[] = {
     {(char*)nullptr, nullptr, nullptr, nullptr, nullptr}
 };
 
-//= CPyCppyy method proxy function behavior ==================================
+//= cpyrt method proxy function behavior ==================================
 static PyObject* mp_vectorcall(
     CPPOverload* pymeth, PyObject* const *args, size_t nargsf, PyObject* kwds)
 {
@@ -680,7 +680,7 @@ static PyObject* mp_vectorcall(
             // this should not happen; set an error to prevent core dump and report
                 PyObject* sig = methods[i]->GetPrototype();
                 PyErr_Format(PyExc_SystemError, "%s =>\n    %s",
-                    CPyCppyy_PyText_AsString(sig), (char*)"nullptr result without error in overload call");
+                    cpyrt_PyText_AsString(sig), (char*)"nullptr result without error in overload call");
                 Py_DECREF(sig);
             }
 
@@ -706,7 +706,7 @@ static PyObject* mp_vectorcall(
     }
 
 // first summarize, then add details
-    PyObject* topmsg = CPyCppyy_PyText_FromFormat(
+    PyObject* topmsg = cpyrt_PyText_FromFormat(
         "none of the %d overloaded methods succeeded. Full details:", (int)nMethods);
     SetDetailedException(std::move(errors), topmsg /* steals */, PyExc_TypeError /* default error */);
 
@@ -720,7 +720,7 @@ static PyObject* mp_str(CPPOverload* cppinst)
 // Print a description that includes the C++ name
      std::ostringstream s;
      s << "<C++ overload \"" << cppinst->fMethodInfo->fName << "\" at " << (void*)cppinst << ">";
-     return CPyCppyy_PyText_FromString(s.str().c_str());
+     return cpyrt_PyText_FromString(s.str().c_str());
 }
 
 //----------------------------------------------------------------------------
@@ -777,7 +777,7 @@ static CPPOverload* mp_descr_get(CPPOverload* pymeth, CPPInstance* pyobj, PyObje
 }
 
 
-//= CPyCppyy method proxy construction/destruction ===========================
+//= cpyrt method proxy construction/destruction ===========================
 static CPPOverload* mp_new(PyTypeObject*, PyObject*, PyObject*)
 {
 // Create a new method proxy object.
@@ -803,7 +803,7 @@ static void mp_dealloc(CPPOverload* pymeth)
     }
 
     if (numfree < CPPOverload_MAXFREELIST) {
-        pymeth->fSelf = (CPyCppyy::CPPInstance*)free_list;
+        pymeth->fSelf = (cppjit::cpyrt::CPPInstance*)free_list;
         free_list = pymeth;
         numfree++;
     } else {
@@ -859,7 +859,7 @@ static PyObject* mp_richcompare(CPPOverload* self, CPPOverload* other, int op)
 }
 
 
-//= CPyCppyy method proxy access to internals ================================
+//= cpyrt method proxy access to internals ================================
 static PyObject* mp_overload(CPPOverload* pymeth, PyObject* args)
 {
 // Select and call a specific C++ overload, based on its signature.
@@ -892,8 +892,8 @@ static PyObject* mp_add_overload(CPPOverload* pymeth, PyObject* new_overload)
 static PyObject* mp_reflex(CPPOverload* pymeth, PyObject* args)
 {
 // Provide the requested reflection information.
-    Cppyy::Reflex::RequestId_t request = -1;
-    Cppyy::Reflex::FormatId_t  format  = Cppyy::Reflex::OPTIMAL;
+    cppjit::interop::Reflex::RequestId_t request = -1;
+    cppjit::interop::Reflex::FormatId_t  format  = cppjit::interop::Reflex::OPTIMAL;
     if (!PyArg_ParseTuple(args, const_cast<char*>("i|i:__cpp_reflex__"), &request, &format))
         return nullptr;
 
@@ -914,10 +914,10 @@ static PyMethodDef mp_methods[] = {
 } // unnamed namespace
 
 
-//= CPyCppyy method proxy type ===============================================
+//= cpyrt method proxy type ===============================================
 PyTypeObject CPPOverload_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.CPPOverload",        // tp_name
+    (char*)"cppjit.CPPOverload",        // tp_name
     sizeof(CPPOverload),               // tp_basicsize
     0,                                 // tp_itemsize
     (destructor)mp_dealloc,            // tp_dealloc
@@ -937,7 +937,7 @@ PyTypeObject CPPOverload_Type = {
     0,                                 // tp_as_buffer
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC
         | Py_TPFLAGS_HAVE_VECTORCALL | Py_TPFLAGS_METHOD_DESCRIPTOR, // tp_flags
-    (char*)"cppyy method proxy (internal)", // tp_doc
+    (char*)"cppjit method proxy (internal)", // tp_doc
     (traverseproc)mp_traverse,         // tp_traverse
     (inquiry)mp_clear,                 // tp_clear
     (richcmpfunc)mp_richcompare,       // tp_richcompare
@@ -966,14 +966,14 @@ PyTypeObject CPPOverload_Type = {
     0,                                 // tp_version_tag
     0,                                 // tp_finalize
     0                                  // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 
 //- public members -----------------------------------------------------------
-void CPyCppyy::CPPOverload::Set(const std::string& name, std::vector<PyCallable*>& methods)
+void cppjit::cpyrt::CPPOverload::Set(const std::string& name, std::vector<PyCallable*>& methods)
 {
 // Fill in the data of a freshly created method proxy.
     fMethodInfo->fName = name;
@@ -993,7 +993,7 @@ void CPyCppyy::CPPOverload::Set(const std::string& name, std::vector<PyCallable*
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::CPPOverload::AdoptMethod(PyCallable* pc)
+void cppjit::cpyrt::CPPOverload::AdoptMethod(PyCallable* pc)
 {
 // Fill in the data of a freshly created method proxy.
     fMethodInfo->fMethods.push_back(pc);
@@ -1001,7 +1001,7 @@ void CPyCppyy::CPPOverload::AdoptMethod(PyCallable* pc)
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::CPPOverload::MergeOverload(CPPOverload* meth)
+void cppjit::cpyrt::CPPOverload::MergeOverload(CPPOverload* meth)
 {
     if (!HasMethods()) // if fresh method being filled: also copy flags
         fMethodInfo->fFlags = meth->fMethodInfo->fFlags;
@@ -1013,7 +1013,7 @@ void CPyCppyy::CPPOverload::MergeOverload(CPPOverload* meth)
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CPPOverload::FindOverload(const std::string& signature, int want_const)
+PyObject* cppjit::cpyrt::CPPOverload::FindOverload(const std::string& signature, int want_const)
 {
     bool accept_any = signature == ":any:";
     CPPOverload* newmeth = nullptr;
@@ -1029,14 +1029,14 @@ PyObject* CPyCppyy::CPPOverload::FindOverload(const std::string& signature, int
         bool found = accept_any;
         if (!found) {
             PyObject* pysig2 = meth->GetSignature(false);
-            std::string sig2(CPyCppyy_PyText_AsString(pysig2));
+            std::string sig2(cpyrt_PyText_AsString(pysig2));
             sig2.erase(std::remove(sig2.begin(), sig2.end(), ' '), std::end(sig2));
             Py_DECREF(pysig2);
             if (sig1 == sig2) found = true;
 
             if (!found) {
                 pysig2 = meth->GetSignature(true);
-                std::string sig3(CPyCppyy_PyText_AsString(pysig2));
+                std::string sig3(cpyrt_PyText_AsString(pysig2));
                 sig3.erase(std::remove(sig3.begin(), sig3.end(), ' '), std::end(sig3));
                 Py_DECREF(pysig2);
                 if (sig1 == sig3) found = true;
@@ -1074,13 +1074,13 @@ PyObject* CPyCppyy::CPPOverload::FindOverload(const std::string& signature, int
     return (PyObject*)newmeth;
 }
 
-PyObject* CPyCppyy::CPPOverload::FindOverload(PyObject *args_tuple, int want_const)
+PyObject* cppjit::cpyrt::CPPOverload::FindOverload(PyObject *args_tuple, int want_const)
 {
     Py_ssize_t n = PyTuple_Size(args_tuple);
 
     CPPOverload::Methods_t& methods = fMethodInfo->fMethods;
 
-    // This value is set based on the maximum penalty in Cppyy::CompareMethodArgType
+    // This value is set based on the maximum penalty in cppjit::interop::CompareMethodArgType
     Py_ssize_t min_score = INT_MAX;
     bool found = false;
     size_t best_method = 0, method_index = 0;
@@ -1108,11 +1108,11 @@ PyObject* CPyCppyy::CPPOverload::FindOverload(PyObject *args_tuple, int want_con
 
         for (int i = 0; i < n; i++) {
             PyObject *pItem = PyTuple_GetItem(args_tuple, i);
-            if(!CPyCppyy_PyText_Check(pItem)) {
+            if(!cpyrt_PyText_Check(pItem)) {
                 PyErr_Format(PyExc_LookupError, "argument types should be in string format");
                 return (PyObject*) nullptr;
             }
-            std::string arg_type(CPyCppyy_PyText_AsString(pItem));
+            std::string arg_type(cpyrt_PyText_AsString(pItem));
             sigargs += arg_type + ", ";
         }
         sigargs += ")";
@@ -1136,7 +1136,7 @@ PyObject* CPyCppyy::CPPOverload::FindOverload(PyObject *args_tuple, int want_con
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::CPPOverload::MethodInfo_t::~MethodInfo_t()
+cppjit::cpyrt::CPPOverload::MethodInfo_t::~MethodInfo_t()
 {
 // Destructor (this object is reference counted).
     for (Methods_t::iterator it = fMethods.begin(); it != fMethods.end(); ++it) {
diff --git a/src/CPyCppyy/src/CPPOverload.h b/src/cpyrt/CPPOverload.h
similarity index 89%
rename from src/CPyCppyy/src/CPPOverload.h
rename to src/cpyrt/CPPOverload.h
index 65c54b4..05d73c4 100644
--- a/src/CPyCppyy/src/CPPOverload.h
+++ b/src/cpyrt/CPPOverload.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_CPPOVERLOAD_H
-#define CPYCPPYY_CPPOVERLOAD_H
+#ifndef CPYRT_CPPOVERLOAD_H
+#define CPYRT_CPPOVERLOAD_H
 
 // Bindings
 #include "PyCallable.h"
@@ -11,19 +11,19 @@
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 // signature hashes are also used by TemplateProxy
-inline uint64_t HashSignature(CPyCppyy_PyArgs_t args, size_t nargsf)
+inline uint64_t HashSignature(cpyrt_PyArgs_t args, size_t nargsf)
 {
 // Build a hash from the types of the given python function arguments.
     uint64_t hash = 0;
 
-    Py_ssize_t nargs = CPyCppyy_PyArgs_GET_SIZE(args, nargsf);
+    Py_ssize_t nargs = cpyrt_PyArgs_GET_SIZE(args, nargsf);
     for (Py_ssize_t i = 0; i < nargs; ++i) {
     // TODO: hashing in the ref-count is for moves; resolve this together with the
     // improved overloads for implicit conversions
-        PyObject* pyobj = CPyCppyy_PyArgs_GET_ITEM(args, i);
+        PyObject* pyobj = cpyrt_PyArgs_GET_ITEM(args, i);
         hash += (uint64_t)Py_TYPE(pyobj);
 #if PY_VERSION_HEX >= 0x030e0000
         hash += (uint64_t)(PyUnstable_Object_IsUniqueReferencedTemporary(pyobj) ? 1 : 0);
@@ -86,7 +86,7 @@ class CPPOverload {
 
 
 //- method proxy type and type verification ----------------------------------
-CPYCPPYY_IMPORT PyTypeObject CPPOverload_Type;
+CPYRT_IMPORT PyTypeObject CPPOverload_Type;
 
 template<typename T>
 inline bool CPPOverload_Check(T* object)
@@ -118,6 +118,6 @@ inline CPPOverload* CPPOverload_New(const std::string& name, PyCallable* method)
     return CPPOverload_New(name, p);
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPOVERLOAD_H
+#endif // !CPYRT_CPPOVERLOAD_H
diff --git a/src/CPyCppyy/src/CPPScope.cxx b/src/cpyrt/CPPScope.cxx
similarity index 80%
rename from src/CPyCppyy/src/CPPScope.cxx
rename to src/cpyrt/CPPScope.cxx
index 841f4bf..a1eedbc 100644
--- a/src/CPyCppyy/src/CPPScope.cxx
+++ b/src/cpyrt/CPPScope.cxx
@@ -1,11 +1,11 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CPPScope.h"
 #include "CPPDataMember.h"
 #include "CPPEnum.h"
 #include "CPPFunction.h"
 #include "CPPOverload.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "CustomPyTypes.h"
 #include "Dispatcher.h"
 #include "ProxyWrappers.h"
@@ -22,7 +22,7 @@
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 extern PyTypeObject CPPInstance_Type;
 
@@ -34,7 +34,7 @@ static inline PyObject* add_template(PyObject* pyclass,
 // specific lookup must be the current overload, if already found.
 
     const std::string& ncl = TypeManip::clean_type(name);
-    PyObject* pyncl = CPyCppyy_PyText_FromString(ncl.c_str());
+    PyObject* pyncl = cpyrt_PyText_FromString(ncl.c_str());
     TemplateProxy* pytmpl = (TemplateProxy*)PyType_Type.tp_getattro(pyclass, pyncl);
     if (!pytmpl) {
         PyErr_Clear();
@@ -65,7 +65,7 @@ static inline PyObject* add_template(PyObject* pyclass,
 }
 
 
-//= CPyCppyy type proxy construction/destruction =============================
+//= cpyrt type proxy construction/destruction =============================
 static PyObject* meta_alloc(PyTypeObject* meta, Py_ssize_t nitems)
 {
 // pure memory allocation; object initialization is in pt_new
@@ -92,28 +92,28 @@ static void meta_dealloc(CPPScope* scope)
 static PyObject* meta_getcppname(CPPScope* scope, void*)
 {
     if ((void*)scope == (void*)&CPPInstance_Type)
-        return CPyCppyy_PyText_FromString("CPPInstance_Type");
-    return CPyCppyy_PyText_FromString(Cppyy::GetScopedFinalName(scope->fCppType).c_str());
+        return cpyrt_PyText_FromString("CPPInstance_Type");
+    return cpyrt_PyText_FromString(cppjit::interop::GetScopedFinalName(scope->fCppType).c_str());
 }
 
 //-----------------------------------------------------------------------------
 static PyObject* meta_getmodule(CPPScope* scope, void*)
 {
     if ((void*)scope == (void*)&CPPInstance_Type)
-        return CPyCppyy_PyText_FromString("cppyy.gbl");
+        return cpyrt_PyText_FromString("cppjit.gbl");
 
     if (scope->fModuleName)
-        return CPyCppyy_PyText_FromString(scope->fModuleName);
+        return cpyrt_PyText_FromString(scope->fModuleName);
 
 // get C++ representation of outer scope
-    Cppyy::TCppScope_t parent_scope = Cppyy::GetParentScope(scope->fCppType);
-    if (parent_scope == Cppyy::GetGlobalScope())
-        return CPyCppyy_PyText_FromString(const_cast<char*>("cppyy.gbl"));
+    cppjit::interop::TCppScope_t parent_scope = cppjit::interop::GetParentScope(scope->fCppType);
+    if (parent_scope == cppjit::interop::GetGlobalScope())
+        return cpyrt_PyText_FromString(const_cast<char*>("cppjit.gbl"));
 
 // now peel scopes one by one, pulling in the python naming (which will
 // simply recurse if not overridden in python)
     PyObject* pymodule = nullptr;
-    PyObject* pyscope = CPyCppyy::GetScopeProxy(parent_scope);
+    PyObject* pyscope = cppjit::cpyrt::GetScopeProxy(parent_scope);
     if (pyscope) {
     // get the module of our module
         pymodule = PyObject_GetAttr(pyscope, PyStrings::gModule);
@@ -121,8 +121,8 @@ static PyObject* meta_getmodule(CPPScope* scope, void*)
         // append name of our module
             PyObject* pymodname = PyObject_GetAttr(pyscope, PyStrings::gName);
             if (pymodname) {
-                CPyCppyy_PyText_AppendAndDel(&pymodule, CPyCppyy_PyText_FromString("."));
-                CPyCppyy_PyText_AppendAndDel(&pymodule, pymodname);
+                cpyrt_PyText_AppendAndDel(&pymodule, cpyrt_PyText_FromString("."));
+                cpyrt_PyText_AppendAndDel(&pymodule, pymodname);
             }
         }
         Py_DECREF(pyscope);
@@ -133,9 +133,9 @@ static PyObject* meta_getmodule(CPPScope* scope, void*)
     PyErr_Clear();
 
 // lookup through python failed, so simply cook up a '::' -> '.' replacement
-    std::string modname = Cppyy::GetScopedFinalName(parent_scope);
+    std::string modname = cppjit::interop::GetScopedFinalName(parent_scope);
     TypeManip::cppscope_to_pyscope(modname);
-    return CPyCppyy_PyText_FromString(("cppyy.gbl."+modname).c_str());
+    return cpyrt_PyText_FromString(("cppjit.gbl."+modname).c_str());
 }
 
 //-----------------------------------------------------------------------------
@@ -143,16 +143,16 @@ static int meta_setmodule(CPPScope* scope, PyObject* value, void*)
 {
     if ((void*)scope == (void*)&CPPInstance_Type) {
         PyErr_SetString(PyExc_AttributeError,
-            "attribute \'__module__\' of 'cppyy.CPPScope\' objects is not writable");
+            "attribute \'__module__\' of 'cppjit.CPPScope\' objects is not writable");
         return -1;
     }
 
-    const char* newname = CPyCppyy_PyText_AsStringChecked(value);
+    const char* newname = cpyrt_PyText_AsStringChecked(value);
     if (!value)
         return -1;
 
     free(scope->fModuleName);
-    Py_ssize_t sz = CPyCppyy_PyText_GET_SIZE(value);
+    Py_ssize_t sz = cpyrt_PyText_GET_SIZE(value);
     scope->fModuleName = (char*)malloc(sz+1);
     memcpy(scope->fModuleName, newname, sz+1);
 
@@ -165,8 +165,8 @@ static PyObject* meta_repr(CPPScope* scope)
 // Specialized b/c type_repr expects __module__ to live in the dictionary,
 // whereas it is a property (to save memory).
     if ((void*)scope == (void*)&CPPInstance_Type)
-        return CPyCppyy_PyText_FromFormat(
-            const_cast<char*>("<class cppyy.CPPInstance at %p>"), scope);
+        return cpyrt_PyText_FromFormat(
+            const_cast<char*>("<class cppjit.CPPInstance at %p>"), scope);
 
     if (scope->fFlags & (CPPScope::kIsMeta | CPPScope::kIsPython)) {
     // either meta type or Python-side derived class: use default type printing
@@ -179,18 +179,18 @@ static PyObject* meta_repr(CPPScope* scope)
 
 // printing of C++ classes
     PyObject* modname = meta_getmodule(scope, nullptr);
-    std::string clName = Cppyy::GetFinalName(scope->fCppType);
+    std::string clName = cppjit::interop::GetFinalName(scope->fCppType);
     const char* kind = (scope->fFlags & CPPScope::kIsNamespace) ? "namespace" : "class";
 
-    PyObject* repr = CPyCppyy_PyText_FromFormat("<%s %s.%s at %p>",
-        kind, CPyCppyy_PyText_AsString(modname), clName.c_str(), scope);
+    PyObject* repr = cpyrt_PyText_FromFormat("<%s %s.%s at %p>",
+        kind, cpyrt_PyText_AsString(modname), clName.c_str(), scope);
 
     Py_DECREF(modname);
     return repr;
 }
 
 
-//= CPyCppyy type metaclass behavior =========================================
+//= cpyrt type metaclass behavior =========================================
 static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
 {
 // Called when CPPScope acts as a metaclass; since type_new always resets
@@ -198,7 +198,7 @@ static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
 // being fixed up here, and the class is initialized here as well.
 
 // fixup of metaclass (left permanent, and in principle only called once b/c
-// cppyy caches python classes)
+// cppjit caches python classes)
     subtype->tp_alloc   = (allocfunc)meta_alloc;
     subtype->tp_dealloc = (destructor)meta_dealloc;
 
@@ -208,10 +208,10 @@ static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
 // This matters beyond performance: GetSmartPtrInfo() resolves the scope name
 // through a slow interpreter lookup that triggers autoloading of the library
 // providing the scope, which we don't want to do unnecessarily.
-    Cppyy::TCppScope_t raw;
-    Cppyy::TCppMethod_t deref;
-    if (CPPScope_CheckExact(subtype) && !Cppyy::IsNamespace(((CPPScope*)subtype)->fCppType)) {
-        if (Cppyy::GetSmartPtrInfo(Cppyy::GetScopedFinalName(((CPPScope*)subtype)->fCppType), &raw, &deref))
+    cppjit::interop::TCppScope_t raw;
+    cppjit::interop::TCppMethod_t deref;
+    if (CPPScope_CheckExact(subtype) && !cppjit::interop::IsNamespace(((CPPScope*)subtype)->fCppType)) {
+        if (cppjit::interop::GetSmartPtrInfo(cppjit::interop::GetScopedFinalName(((CPPScope*)subtype)->fCppType), &raw, &deref))
             subtype->tp_basicsize = sizeof(CPPSmartClass);
     }
 
@@ -235,10 +235,10 @@ static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
     if (!CPPScope_CheckExact(subtype) || !strstr(subtype->tp_name, "_meta") /* convention */) {
     // there has been a user meta class override in a derived class, so do
     // the consistent thing, thus allowing user control over naming
-        result->fCppType = Cppyy::GetScope(
-            CPyCppyy_PyText_AsString(PyTuple_GET_ITEM(args, 0)));
+        result->fCppType = cppjit::interop::GetScope(
+            cpyrt_PyText_AsString(PyTuple_GET_ITEM(args, 0)));
     } else {
-    // coming here from cppyy or from sub-classing in python; take the
+    // coming here from cppjit or from sub-classing in python; take the
     // C++ type from the meta class to make sure that the latter category
     // has fCppType properly set (it inherits the meta class, but has an
     // otherwise unknown (or wrong) C++ type)
@@ -252,7 +252,7 @@ static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
         if (3 <= PyTuple_GET_SIZE(args)) {
             PyObject* dct = PyTuple_GET_ITEM(args, 2);
             Py_ssize_t sz = PyDict_Size(dct);
-            if (0 < sz && !Cppyy::IsNamespace(result->fCppType)) {
+            if (0 < sz && !cppjit::interop::IsNamespace(result->fCppType)) {
                 result->fFlags |= CPPScope::kIsPython;
                 if (1 < PyTuple_GET_SIZE(PyTuple_GET_ITEM(args, 1)))
                     result->fFlags |= CPPScope::kIsMultiCross;
@@ -264,7 +264,7 @@ static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
                 // the direct base can be useful for some templates, such as shared_ptrs,
                 // so make it accessible (the __cpp_cross__ data member also signals that
                 // this is a cross-inheritance class)
-                    PyObject* bname = CPyCppyy_PyText_FromString(Cppyy::GetBaseName(result->fCppType, 0).c_str());
+                    PyObject* bname = cpyrt_PyText_FromString(cppjit::interop::GetBaseName(result->fCppType, 0).c_str());
                     if (PyObject_SetAttrString((PyObject*)result, "__cpp_cross__", bname) == -1)
                         PyErr_Clear();
                     Py_DECREF(bname);
@@ -280,9 +280,9 @@ static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds)
         return (PyObject*)result;
 
 // maps for using namespaces and tracking objects
-    if (!Cppyy::IsNamespace(result->fCppType)) {
-        static Cppyy::TCppScope_t exc_type = Cppyy::GetScope("exception", Cppyy::GetScope("std"));
-        if (Cppyy::IsSubclass(result->fCppType, exc_type))
+    if (!cppjit::interop::IsNamespace(result->fCppType)) {
+        static cppjit::interop::TCppScope_t exc_type = cppjit::interop::GetScope("exception", cppjit::interop::GetScope("std"));
+        if (cppjit::interop::IsSubclass(result->fCppType, exc_type))
             result->fFlags |= CPPScope::kIsException;
         if (!(result->fFlags & CPPScope::kIsPython))
             result->fImp.fCppObjects = new CppToPyMap_t;
@@ -342,11 +342,11 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
             return attr;
     }
 
-    if (!CPyCppyy_PyText_CheckExact(pyname) || !CPPScope_Check(pyclass))
+    if (!cpyrt_PyText_CheckExact(pyname) || !CPPScope_Check(pyclass))
         return possibly_shadowed;
 
 // filter for python specials
-    std::string name = CPyCppyy_PyText_AsString(pyname);
+    std::string name = cpyrt_PyText_AsString(pyname);
     if (name.size() >= 5 && name.compare(0, 2, "__") == 0 &&
             name.compare(name.size()-2, name.size(), "__") == 0)
         return possibly_shadowed;
@@ -365,15 +365,15 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
     CPPScope* klass = ((CPPScope*)pyclass);
     if (!attr) {
         Utility::FetchError(errors);
-        Cppyy::TCppScope_t scope = klass->fCppType;
+        cppjit::interop::TCppScope_t scope = klass->fCppType;
 
     // namespaces may have seen updates in their list of global functions, which
     // are available as "methods" even though they're not really that
         if ((klass->fFlags & CPPScope::kIsNamespace) || 
-                scope == Cppyy::GetGlobalScope()) {
+                scope == cppjit::interop::GetGlobalScope()) {
         // tickle lazy lookup of functions
-            const std::vector<Cppyy::TCppMethod_t> methods =
-                Cppyy::GetMethodsFromName(scope, name);
+            const std::vector<cppjit::interop::TCppMethod_t> methods =
+                cppjit::interop::GetMethodsFromName(scope, name);
             if (!methods.empty()) {
             // function exists, now collect overloads
                 std::vector<PyCallable*> overloads;
@@ -384,7 +384,7 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
             // Note: can't re-use Utility::AddClass here, as there's the risk of
             // a recursive call. Simply add method directly, as we're guaranteed
             // that it doesn't exist yet.
-                if (Cppyy::ExistsMethodTemplate(scope, name))
+                if (cppjit::interop::ExistsMethodTemplate(scope, name))
                     attr = add_template(pyclass, name, &overloads);
                 else
                     attr = (PyObject*)CPPOverload_New(name, overloads);
@@ -393,14 +393,14 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
         }
 
         if (!attr) {
-            Cppyy::TCppScope_t lookup_result = Cppyy::GetNamed(name, scope);
-            if (Cppyy::IsVariable(lookup_result) || Cppyy::IsEnumConstant(lookup_result)) {
+            cppjit::interop::TCppScope_t lookup_result = cppjit::interop::GetNamed(name, scope);
+            if (cppjit::interop::IsVariable(lookup_result) || cppjit::interop::IsEnumConstant(lookup_result)) {
                 attr = (PyObject*)CPPDataMember_New(scope, lookup_result);
-            } else if (Cppyy::IsTypedefed(lookup_result)) {
-                Cppyy::TCppType_t resolved_type = Cppyy::ResolveType(Cppyy::GetTypeFromScope(lookup_result));
-                const std::string& cpd = TypeManip::compound(Cppyy::GetTypeAsString(resolved_type));
+            } else if (cppjit::interop::IsTypedefed(lookup_result)) {
+                cppjit::interop::TCppType_t resolved_type = cppjit::interop::ResolveType(cppjit::interop::GetTypeFromScope(lookup_result));
+                const std::string& cpd = TypeManip::compound(cppjit::interop::GetTypeAsString(resolved_type));
                 if (cpd == "*") {
-                    Cppyy::TCppScope_t tcl = Cppyy::GetScopeFromType(Cppyy::ResolveType(resolved_type));
+                    cppjit::interop::TCppScope_t tcl = cppjit::interop::GetScopeFromType(cppjit::interop::ResolveType(resolved_type));
                     if (tcl) {
                         typedefpointertoclassobject* tpc =
                             PyObject_New(typedefpointertoclassobject, &TypedefPointerToClass_Type);
@@ -414,7 +414,7 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
     // function templates that have not been instantiated (namespaces _may_ have already
     // been taken care of, by their general function lookup above)
         if (!attr && !templated_functions_checked) {
-            if (Cppyy::ExistsMethodTemplate(scope, name))
+            if (cppjit::interop::ExistsMethodTemplate(scope, name))
                 attr = add_template(pyclass, name);
             else {
             // for completeness in error reporting
@@ -425,8 +425,8 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
 
     // enums types requested as type (rather than the constants)
         if (!attr) {
-            Cppyy::TCppScope_t enumerator = Cppyy::GetUnderlyingScope(Cppyy::GetNamed(name, scope));
-            if (Cppyy::IsEnumScope(enumerator)) {
+            cppjit::interop::TCppScope_t enumerator = cppjit::interop::GetUnderlyingScope(cppjit::interop::GetNamed(name, scope));
+            if (cppjit::interop::IsEnumScope(enumerator)) {
             // enum types (incl. named and class enums)
                 attr = (PyObject*)CPPEnum_New(name, enumerator);
             } else {
@@ -456,7 +456,7 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
 
     if (!attr && (klass->fFlags & CPPScope::kIsNamespace)) {
     // refresh using list as necessary
-        const std::vector<Cppyy::TCppScope_t>& uv = Cppyy::GetUsingNamespaces(klass->fCppType);
+        const std::vector<cppjit::interop::TCppScope_t>& uv = cppjit::interop::GetUsingNamespaces(klass->fCppType);
         if (!klass->fImp.fUsing || uv.size() != klass->fImp.fUsing->size()) {
             if (klass->fImp.fUsing) {
                 for (auto pyref : *klass->fImp.fUsing) Py_DECREF(pyref);
@@ -466,12 +466,12 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
 
         // reload and reset weak refs
             for (auto uid : uv) {
-                std::string uname = Cppyy::GetScopedFinalName(uid);
+                std::string uname = cppjit::interop::GetScopedFinalName(uid);
                 PyObject* pyuscope = CreateScopeProxy(uname);
                 if (pyuscope) {
                     klass->fImp.fUsing->push_back(PyWeakref_NewRef(pyuscope, nullptr));
                 // the namespace may not otherwise be held, so tie the lifetimes
-                    PyObject* llname = CPyCppyy_PyText_FromString(("__lifeline_"+uname).c_str());
+                    PyObject* llname = cpyrt_PyText_FromString(("__lifeline_"+uname).c_str());
                     PyType_Type.tp_setattro(pyclass, llname, pyuscope);
                     Py_DECREF(llname);
                     Py_DECREF(pyuscope);
@@ -484,7 +484,7 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
     // try all outstanding using namespaces in turn to find the attribute (will cache
     // locally later; TODO: doing so may cause pathological cases)
         for (auto pyref : *klass->fImp.fUsing) {
-            PyObject* pyuscope = CPyCppyy_GetWeakRef(pyref);
+            PyObject* pyuscope = cpyrt_GetWeakRef(pyref);
             if (pyuscope) {
                 attr = PyObject_GetAttr(pyuscope, pyname);
                 if (!attr) PyErr_Clear();
@@ -518,12 +518,12 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
         PyObject* sklass = PyObject_Str(pyclass);
         PyErr_Restore(pytype, pyvalue, pytrace);
         if (sklass) {
-            topmsg = CPyCppyy_PyText_FromFormat("%s has no attribute \'%s\'. Full details:",
-                CPyCppyy_PyText_AsString(sklass), CPyCppyy_PyText_AsString(pyname));
+            topmsg = cpyrt_PyText_FromFormat("%s has no attribute \'%s\'. Full details:",
+                cpyrt_PyText_AsString(sklass), cpyrt_PyText_AsString(pyname));
             Py_DECREF(sklass);
         } else {
-            topmsg = CPyCppyy_PyText_FromFormat("no such attribute \'%s\'. Full details:",
-                CPyCppyy_PyText_AsString(pyname));
+            topmsg = cpyrt_PyText_FromFormat("no such attribute \'%s\'. Full details:",
+                cpyrt_PyText_AsString(pyname));
         }
         SetDetailedException(std::move(errors), topmsg /* steals */, PyExc_AttributeError /* default error */);
     }
@@ -541,10 +541,10 @@ static int meta_setattro(PyObject* pyclass, PyObject* pyname, PyObject* pyval)
 // are needed to prevent unnecessary lookups and recursion.
     // skip if the given pyval is a descriptor already, or an unassignable class
     if (((CPPScope*)pyclass)->fFlags & CPPScope::kIsNamespace
-        && !CPyCppyy::CPPDataMember_Check(pyval)
-        && !CPyCppyy::CPPScope_Check(pyval)) {
-        std::string name = CPyCppyy_PyText_AsString(pyname);
-        if (Cppyy::GetNamed(name, ((CPPScope*)pyclass)->fCppType))
+        && !cppjit::cpyrt::CPPDataMember_Check(pyval)
+        && !cppjit::cpyrt::CPPScope_Check(pyval)) {
+        std::string name = cpyrt_PyText_AsString(pyname);
+        if (cppjit::interop::GetNamed(name, ((CPPScope*)pyclass)->fCppType))
             meta_getattro(pyclass, pyname);       // triggers creation
     }
 
@@ -556,22 +556,22 @@ static int meta_setattro(PyObject* pyclass, PyObject* pyname, PyObject* pyval)
 static PyObject* meta_reflex(CPPScope* klass, PyObject* args)
 {
 // Provide the requested reflection information.
-    Cppyy::Reflex::RequestId_t request = -1;
-    Cppyy::Reflex::FormatId_t  format  = Cppyy::Reflex::OPTIMAL;
+    cppjit::interop::Reflex::RequestId_t request = -1;
+    cppjit::interop::Reflex::FormatId_t  format  = cppjit::interop::Reflex::OPTIMAL;
     if (!PyArg_ParseTuple(args, const_cast<char*>("i|i:__cpp_reflex__"), &request, &format))
         return nullptr;
 
     switch (request) {
-    case Cppyy::Reflex::IS_NAMESPACE:
+    case cppjit::interop::Reflex::IS_NAMESPACE:
         if (klass->fFlags & CPPScope::kIsNamespace)
             Py_RETURN_TRUE;
         Py_RETURN_FALSE;
         break;
-    case Cppyy::Reflex::IS_AGGREGATE:
+    case cppjit::interop::Reflex::IS_AGGREGATE:
       // this is not the strict C++ definition of aggregates, but is closer to what
       // is needed for Numba and C calling conventions (TODO: probably have to check
       // for all public data types, too, and maybe for no padding?)
-        if (Cppyy::IsAggregate(klass->fCppType) || !Cppyy::HasVirtualDestructor(klass->fCppType))
+        if (cppjit::interop::IsAggregate(klass->fCppType) || !cppjit::interop::HasVirtualDestructor(klass->fCppType))
             Py_RETURN_TRUE;
         Py_RETURN_FALSE;
         break;
@@ -591,12 +591,12 @@ static PyObject* meta_dir(CPPScope* klass)
 // Collect a list of everything (currently) available in the namespace.
 // The backend can filter by returning empty strings. Special care is
 // taken for functions, which need not be unique (overloading).
-    using namespace Cppyy;
+    using namespace cppjit::interop;
 
     if ((void*)klass == (void*)&CPPInstance_Type)
         return PyList_New(0);
 
-    if (!CPyCppyy::CPPScope_Check((PyObject*)klass)) {
+    if (!cppjit::cpyrt::CPPScope_Check((PyObject*)klass)) {
         PyErr_SetString(PyExc_TypeError, "C++ proxy scope expected");
         return nullptr;
     }
@@ -606,7 +606,7 @@ static PyObject* meta_dir(CPPScope* klass)
         return dirlist;
 
     std::set<std::string> cppnames;
-    Cppyy::GetAllCppNames(klass->fCppType, cppnames);
+    cppjit::interop::GetAllCppNames(klass->fCppType, cppnames);
 
 // cleanup names
     std::set<std::string> dir_cppnames;
@@ -619,7 +619,7 @@ static PyObject* meta_dir(CPPScope* klass)
 
 // get rid of duplicates
     for (Py_ssize_t i = 0; i < PyList_GET_SIZE(dirlist); ++i)
-        dir_cppnames.insert(CPyCppyy_PyText_AsString(PyList_GET_ITEM(dirlist, i)));
+        dir_cppnames.insert(cpyrt_PyText_AsString(PyList_GET_ITEM(dirlist, i)));
 
     Py_DECREF(dirlist);
     dirlist = PyList_New(dir_cppnames.size());
@@ -627,7 +627,7 @@ static PyObject* meta_dir(CPPScope* klass)
 // copy total onto python list
     Py_ssize_t i = 0;
     for (const auto& name : dir_cppnames) {
-        PyList_SET_ITEM(dirlist, i++, CPyCppyy_PyText_FromString(name.c_str()));
+        PyList_SET_ITEM(dirlist, i++, cpyrt_PyText_FromString(name.c_str()));
     }
     return dirlist;
 }
@@ -649,11 +649,11 @@ static PyGetSetDef meta_getset[] = {
 };
 
 
-//= CPyCppyy object proxy type type ==========================================
+//= cpyrt object proxy type type ==========================================
 PyTypeObject CPPScope_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.CPPScope",       // tp_name
-    sizeof(CPyCppyy::CPPScope),    // tp_basicsize
+    (char*)"cppjit.CPPScope",       // tp_name
+    sizeof(cppjit::cpyrt::CPPScope),    // tp_basicsize
     0,                             // tp_itemsize
     0,                             // tp_dealloc
     0,                             // tp_vectorcall_offset / tp_print
@@ -671,7 +671,7 @@ PyTypeObject CPPScope_Type = {
     (setattrofunc)meta_setattro,   // tp_setattro
     0,                             // tp_as_buffer
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TYPE_SUBCLASS, // tp_flags
-    (char*)"CPyCppyy metatype (internal)",        // tp_doc
+    (char*)"cpyrt metatype (internal)",        // tp_doc
     0,                             // tp_traverse
     0,                             // tp_clear
     0,                             // tp_richcompare
@@ -700,7 +700,7 @@ PyTypeObject CPPScope_Type = {
     0,                             // tp_version_tag
     0,                             // tp_finalize
     0                              // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
diff --git a/src/CPyCppyy/src/CPPScope.h b/src/cpyrt/CPPScope.h
similarity index 85%
rename from src/CPyCppyy/src/CPPScope.h
rename to src/cpyrt/CPPScope.h
index 355dfae..1f4639a 100644
--- a/src/CPyCppyy/src/CPPScope.h
+++ b/src/cpyrt/CPPScope.h
@@ -1,8 +1,8 @@
-#ifndef CPYCPPYY_CPPSCOPE_H
-#define CPYCPPYY_CPPSCOPE_H
+#ifndef CPYRT_CPPSCOPE_H
+#define CPYRT_CPPSCOPE_H
 
 #include "Python.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include <unordered_map>
 
 #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION == 2
@@ -27,7 +27,7 @@ typedef struct {
 #include <map>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 /** Type object to hold class reference (this is only semantically a presentation
     of CPPScope instances, not in a C++ sense)
@@ -36,7 +36,7 @@ namespace CPyCppyy {
       @version 2.0
  */
 
-typedef std::unordered_map<Cppyy::TCppObject_t, PyObject*> CppToPyMap_t;
+typedef std::unordered_map<cppjit::interop::TCppObject_t, PyObject*> CppToPyMap_t;
 namespace Utility { struct PyOperators; }
 
 class CPPScope {
@@ -57,7 +57,7 @@ class CPPScope {
 
 public:
     PyHeapTypeObject   fType;
-    Cppyy::TCppScope_t fCppType;
+    cppjit::interop::TCppScope_t fCppType;
     uint32_t           fFlags;
     union {
         CppToPyMap_t*           fCppObjects;     // classes only
@@ -74,8 +74,8 @@ typedef CPPScope CPPClass;
 
 class CPPSmartClass : public CPPClass {
 public:
-    Cppyy::TCppScope_t  fUnderlyingType;
-    Cppyy::TCppMethod_t fDereferencer;
+    cppjit::interop::TCppScope_t  fUnderlyingType;
+    cppjit::interop::TCppMethod_t fDereferencer;
 };
 
 
@@ -99,7 +99,7 @@ inline bool CPPScope_CheckExact(T* object)
 }
 
 //- creation -----------------------------------------------------------------
-inline CPPScope* CPPScopeMeta_New(Cppyy::TCppScope_t klass, PyObject* args)
+inline CPPScope* CPPScopeMeta_New(cppjit::interop::TCppScope_t klass, PyObject* args)
 {
 // Create and initialize a new scope meta class
     CPPScope* pymeta = (CPPScope*)PyType_Type.tp_new(&CPPScope_Type, args, nullptr);
@@ -115,6 +115,6 @@ inline CPPScope* CPPScopeMeta_New(Cppyy::TCppScope_t klass, PyObject* args)
     return pymeta;
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CPPSCOPE_H
+#endif // !CPYRT_CPPSCOPE_H
diff --git a/src/CPyCppyy/src/CallContext.cxx b/src/cpyrt/CallContext.cxx
similarity index 82%
rename from src/CPyCppyy/src/CallContext.cxx
rename to src/cpyrt/CallContext.cxx
index 759765b..f3344df 100644
--- a/src/CPyCppyy/src/CallContext.cxx
+++ b/src/cpyrt/CallContext.cxx
@@ -1,19 +1,19 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CallContext.h"
 
 
 //- data _____________________________________________________________________
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
     CallContext::ECallFlags CallContext::sMemoryPolicy = CallContext::kUseStrict;
-// this is just a data holder for linking; actual value is set in CPyCppyyModule.cxx
+// this is just a data holder for linking; actual value is set in cpyrtModule.cxx
     CallContext::ECallFlags CallContext::sSignalPolicy = CallContext::kNone;
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::CallContext::AddTemporary(PyObject* pyobj) {
+void cppjit::cpyrt::CallContext::AddTemporary(PyObject* pyobj) {
     if (pyobj) {
         if (!fTemps)
             fTemps = new Temporary{pyobj, nullptr};
@@ -26,7 +26,7 @@ void CPyCppyy::CallContext::AddTemporary(PyObject* pyobj) {
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::CallContext::Cleanup() {
+void cppjit::cpyrt::CallContext::Cleanup() {
     Temporary* tmp = fTemps;
     while (tmp) {
         Py_DECREF(tmp->fPyObject);
@@ -38,7 +38,7 @@ void CPyCppyy::CallContext::Cleanup() {
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::CallContext::SetMemoryPolicy(ECallFlags e)
+bool cppjit::cpyrt::CallContext::SetMemoryPolicy(ECallFlags e)
 {
 // Set the global memory policy, which affects object ownership when objects
 // are passed as function arguments.
@@ -50,7 +50,7 @@ bool CPyCppyy::CallContext::SetMemoryPolicy(ECallFlags e)
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::CallContext::SetGlobalSignalPolicy(bool setProtected)
+bool cppjit::cpyrt::CallContext::SetGlobalSignalPolicy(bool setProtected)
 {
 // Set the global signal policy, which determines whether a jmp address
 // should be saved to return to after a C++ segfault.
diff --git a/src/CPyCppyy/src/CallContext.h b/src/cpyrt/CallContext.h
similarity index 95%
rename from src/CPyCppyy/src/CallContext.h
rename to src/cpyrt/CallContext.h
index f093959..6c5a519 100644
--- a/src/CPyCppyy/src/CallContext.h
+++ b/src/cpyrt/CallContext.h
@@ -1,8 +1,8 @@
-#ifndef CPYCPPYY_CALLCONTEXT_H
-#define CPYCPPYY_CALLCONTEXT_H
+#ifndef CPYRT_CALLCONTEXT_H
+#define CPYRT_CALLCONTEXT_H
 
 #include "Python.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 
 // Standard
 #include <vector>
@@ -11,7 +11,7 @@
 #include <sys/types.h>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 // small number that allows use of stack for argument passing
 const int SMALL_ARGS_N = 8;
@@ -19,8 +19,8 @@ const int SMALL_ARGS_N = 8;
 // convention to pass flag for direct calls (similar to Python's vector calls)
 #define DIRECT_CALL ((size_t)1 << (8 * sizeof(size_t) - 1))
 
-#ifndef CPYCPPYY_PARAMETER
-#define CPYCPPYY_PARAMETER
+#ifndef CPYRT_PARAMETER
+#define CPYRT_PARAMETER
 // general place holder for function parameters
 struct Parameter {
     union Value {
@@ -46,7 +46,7 @@ struct Parameter {
     void* fRef;
     char  fTypeCode;
 };
-#endif // CPYCPPYY_PARAMETER
+#endif // CPYRT_PARAMETER
 
 // extra call information
 struct CallContext {
@@ -108,7 +108,7 @@ struct CallContext {
 
 public:
 // info/status
-    Cppyy::TCppScope_t fCurScope;
+    cppjit::interop::TCppScope_t fCurScope;
     PyObject*          fPyContext;
     uint32_t           fFlags;
 
@@ -177,6 +177,6 @@ class CallContextRAII {
     bool fPrior;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CALLCONTEXT_H
+#endif // !CPYRT_CALLCONTEXT_H
diff --git a/src/cpyrt/CommonDefs.h b/src/cpyrt/CommonDefs.h
new file mode 100644
index 0000000..0db7320
--- /dev/null
+++ b/src/cpyrt/CommonDefs.h
@@ -0,0 +1,34 @@
+#ifndef CPYRT_COMMONDEFS_H
+#define CPYRT_COMMONDEFS_H
+
+// export macros for our own API
+// import/export (after precommondefs.h from PyPy)
+#ifdef _MSC_VER
+// Windows requires symbols to be explicitly exported
+#define CPYRT_EXPORT extern __declspec(dllexport)
+#define CPYRT_IMPORT extern __declspec(dllimport)
+#define CPYRT_CLASS_EXPORT __declspec(dllexport)
+
+// CPYRT_EXTERN is dual use in the public API
+#ifndef CPYRT_INTERNAL
+#define CPYRT_EXTERN extern __declspec(dllexport)
+#define CPYRT_CLASS_EXTERN __declspec(dllexport)
+#else
+#define CPYRT_EXTERN extern __declspec(dllimport)
+#define CPYRT_CLASS_EXTERN __declspec(dllimport)
+#endif
+
+#define CPYRT_STATIC
+
+#else
+// Linux, Mac, etc.
+#define CPYRT_EXPORT extern
+#define CPYRT_IMPORT extern
+#define CPYRT_CLASS_EXPORT
+#define CPYRT_EXTERN extern
+#define CPYRT_CLASS_EXTERN
+#define CPYRT_STATIC static
+
+#endif
+
+#endif // !CPYRT_COMMONDEFS_H
diff --git a/src/CPyCppyy/src/Converters.cxx b/src/cpyrt/Converters.cxx
similarity index 82%
rename from src/CPyCppyy/src/Converters.cxx
rename to src/cpyrt/Converters.cxx
index c302129..67a1c0f 100644
--- a/src/CPyCppyy/src/Converters.cxx
+++ b/src/cpyrt/Converters.cxx
@@ -1,6 +1,6 @@
 // Bindings
-#include "CPyCppyy.h"
-#include "Cppyy.h"
+#include "cpyrt.h"
+#include "cppjit_interop.h"
 #include "DeclareConverters.h"
 #include "CallContext.h"
 #include "CPPExcInstance.h"
@@ -36,7 +36,7 @@
 
 
 //- data _____________________________________________________________________
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 // factories
     typedef std::unordered_map<std::string, cf_t> ConvFactories_t;
@@ -60,13 +60,13 @@ inline bool PyUnstable_Object_IsUniqueReferencedTemporary(PyObject *pyobject) {
 #endif
 
 //- pretend-ctypes helpers ---------------------------------------------------
-struct CPyCppyy_tagCDataObject {       // non-public (but stable)
+struct cpyrt_tagCDataObject {       // non-public (but stable)
     PyObject_HEAD
     char* b_ptr;
     int   b_needsfree;
 };
 
-struct CPyCppyy_tagPyCArgObject {      // not public (but stable; note that older
+struct cpyrt_tagPyCArgObject {      // not public (but stable; note that older
     PyObject_HEAD                      // Pythons protect 'D' with HAVE_LONG_LONG)
     void* pffi_type;
     char tag;
@@ -235,17 +235,17 @@ typedef struct {
     PyTypeObject *UnionType_Type;
     PyTypeObject *PyCPointerType_Type;
 // ... unused fields omitted ...
-} _cppyy_ctypes_state;
+} _cppjit_ctypes_state;
 
 } // unnamed namespace
 
 static bool IsCTypesArrayOrPointer(PyObject* pyobject)
 {
-    static _cppyy_ctypes_state* state = nullptr;
+    static _cppjit_ctypes_state* state = nullptr;
     if (!state) {
         PyObject* ctmod = PyImport_AddModule("_ctypes");   // the extension module, not the Python one
         if (ctmod)
-            state = (_cppyy_ctypes_state*)PyModule_GetState(ctmod);
+            state = (_cppjit_ctypes_state*)PyModule_GetState(ctmod);
     }
 
     // verify for object types that have a C payload
@@ -294,10 +294,10 @@ static bool HasLifeLine(PyObject* holder, intptr_t ref)
 
 
 //- helper to work with both CPPInstance and CPPExcInstance ------------------
-static inline CPyCppyy::CPPInstance* GetCppInstance(
-    PyObject* pyobject, Cppyy::TCppScope_t klass = Cppyy::TCppScope_t{}, bool accept_rvalue = false)
+static inline cppjit::cpyrt::CPPInstance* GetCppInstance(
+    PyObject* pyobject, cppjit::interop::TCppScope_t klass = cppjit::interop::TCppScope_t{}, bool accept_rvalue = false)
 {
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
     if (CPPInstance_Check(pyobject))
         return (CPPInstance*)pyobject;
     if (CPPExcInstance_Check(pyobject))
@@ -334,9 +334,9 @@ static inline CPyCppyy::CPPInstance* GetCppInstance(
 
 
 //- custom helpers to check ranges -------------------------------------------
-static inline bool ImplicitBool(PyObject* pyobject, CPyCppyy::CallContext* ctxt)
+static inline bool ImplicitBool(PyObject* pyobject, cppjit::cpyrt::CallContext* ctxt)
 {
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
     if (!AllowImplicit(ctxt) && PyBool_Check(pyobject)) {
         if (!NoImplicit(ctxt)) ctxt->fFlags |= CallContext::kHaveImplicit;
         return false;
@@ -344,9 +344,9 @@ static inline bool ImplicitBool(PyObject* pyobject, CPyCppyy::CallContext* ctxt)
     return true;
 }
 
-static inline bool StrictBool(PyObject* pyobject, CPyCppyy::CallContext* ctxt)
+static inline bool StrictBool(PyObject* pyobject, cppjit::cpyrt::CallContext* ctxt)
 {
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
     if (!AllowImplicit(ctxt) && !PyBool_Check(pyobject)) {
         if (!NoImplicit(ctxt)) ctxt->fFlags |= CallContext::kHaveImplicit;
         return false;
@@ -354,7 +354,7 @@ static inline bool StrictBool(PyObject* pyobject, CPyCppyy::CallContext* ctxt)
     return true;
 }
 
-static inline bool CPyCppyy_PyLong_AsBool(PyObject* pyobject)
+static inline bool cpyrt_PyLong_AsBool(PyObject* pyobject)
 {
 // range-checking python integer to C++ bool conversion
     long l = PyLong_AsLong(pyobject);
@@ -368,11 +368,11 @@ static inline bool CPyCppyy_PyLong_AsBool(PyObject* pyobject)
 
 
 // range-checking python integer to C++ integer conversion (prevents p2.7 silent conversions)
-#define CPPYY_PYLONG_AS_TYPE(name, type, limit_low, limit_high)              \
-static inline type CPyCppyy_PyLong_As##name(PyObject* pyobject)              \
+#define CPPJIT_PYLONG_AS_TYPE(name, type, limit_low, limit_high)              \
+static inline type cpyrt_PyLong_As##name(PyObject* pyobject)              \
 {                                                                            \
     if (!(PyLong_Check(pyobject) || PyInt_Check(pyobject))) {                \
-        if (pyobject == CPyCppyy::gDefaultObject)                            \
+        if (pyobject == cppjit::cpyrt::gDefaultObject)                            \
             return (type)0;                                                  \
         PyErr_SetString(PyExc_TypeError, #type" conversion expects an integer object");\
         return (type)-1;                                                     \
@@ -385,19 +385,19 @@ static inline type CPyCppyy_PyLong_As##name(PyObject* pyobject)              \
     return (type)l;                                                          \
 }
 
-CPPYY_PYLONG_AS_TYPE(UInt8,     uint8_t,        0,         UCHAR_MAX)
-CPPYY_PYLONG_AS_TYPE(Int8,      int8_t,         SCHAR_MIN, SCHAR_MAX)
-CPPYY_PYLONG_AS_TYPE(UShort,    unsigned short, 0,         USHRT_MAX)
-CPPYY_PYLONG_AS_TYPE(Short,     short,          SHRT_MIN,  SHRT_MAX)
-CPPYY_PYLONG_AS_TYPE(StrictInt, int,            INT_MIN,   INT_MAX)
+CPPJIT_PYLONG_AS_TYPE(UInt8,     uint8_t,        0,         UCHAR_MAX)
+CPPJIT_PYLONG_AS_TYPE(Int8,      int8_t,         SCHAR_MIN, SCHAR_MAX)
+CPPJIT_PYLONG_AS_TYPE(UShort,    unsigned short, 0,         USHRT_MAX)
+CPPJIT_PYLONG_AS_TYPE(Short,     short,          SHRT_MIN,  SHRT_MAX)
+CPPJIT_PYLONG_AS_TYPE(StrictInt, int,            INT_MIN,   INT_MAX)
 
-static inline long CPyCppyy_PyLong_AsStrictLong(PyObject* pyobject)
+static inline long cpyrt_PyLong_AsStrictLong(PyObject* pyobject)
 {
 // strict python integer to C++ long integer conversion
 
-// prevent float -> long (see CPyCppyy_PyLong_AsStrictInt)
+// prevent float -> long (see cpyrt_PyLong_AsStrictInt)
     if (!(PyLong_Check(pyobject) || PyInt_Check(pyobject))) {
-        if (pyobject == CPyCppyy::gDefaultObject)
+        if (pyobject == cppjit::cpyrt::gDefaultObject)
             return (long)0;
         PyErr_SetString(PyExc_TypeError, "int/long conversion expects an integer object");
         return (long)-1;
@@ -406,13 +406,13 @@ static inline long CPyCppyy_PyLong_AsStrictLong(PyObject* pyobject)
     return (long)PyLong_AsLong(pyobject);   // already does long range check
 }
 
-static inline PY_LONG_LONG CPyCppyy_PyLong_AsStrictLongLong(PyObject* pyobject)
+static inline PY_LONG_LONG cpyrt_PyLong_AsStrictLongLong(PyObject* pyobject)
 {
 // strict python integer to C++ long long integer conversion
 
-// prevent float -> long (see CPyCppyy_PyLong_AsStrictInt)
+// prevent float -> long (see cpyrt_PyLong_AsStrictInt)
     if (!(PyLong_Check(pyobject) || PyInt_Check(pyobject))) {
-        if (pyobject == CPyCppyy::gDefaultObject)
+        if (pyobject == cppjit::cpyrt::gDefaultObject)
             return (PY_LONG_LONG)0;
         PyErr_SetString(PyExc_TypeError, "int/long conversion expects an integer object");
         return (PY_LONG_LONG)-1;
@@ -424,13 +424,13 @@ static inline PY_LONG_LONG CPyCppyy_PyLong_AsStrictLongLong(PyObject* pyobject)
 
 //- helper for pointer/array/reference conversions ---------------------------
 static inline bool CArraySetArg(
-    PyObject* pyobject, CPyCppyy::Parameter& para, char tc, int size, bool check=true)
+    PyObject* pyobject, cppjit::cpyrt::Parameter& para, char tc, int size, bool check=true)
 {
 // Case of LowLevelView. In general, they also implement the buffer protocol,
 // but for views around nullptr or C-style arrays without size info the buffer
 // protocol implementation is incomplete and PyObject_GetBuffer will fail.
-    if (CPyCppyy::LowLevelView_Check(pyobject)) {
-        auto llview = ((CPyCppyy::LowLevelView*)pyobject);
+    if (cppjit::cpyrt::LowLevelView_Check(pyobject)) {
+        auto llview = ((cppjit::cpyrt::LowLevelView*)pyobject);
         if (llview->fBufInfo.itemsize != size || !strchr(llview->fBufInfo.format, tc)) {
             PyErr_Format(PyExc_TypeError,
                 "could not convert argument to buffer or nullptr");
@@ -440,13 +440,13 @@ static inline bool CArraySetArg(
         para.fValue.fVoidp = llview->get_buf();
     }
 // general case of loading a C array pointer (void* + type code) as function argument
-    else if (pyobject == CPyCppyy::gNullPtrObject || pyobject == CPyCppyy::gDefaultObject)
+    else if (pyobject == cppjit::cpyrt::gNullPtrObject || pyobject == cppjit::cpyrt::gDefaultObject)
         para.fValue.fVoidp = nullptr;
     else {
-        Py_ssize_t buflen = CPyCppyy::Utility::GetBuffer(pyobject, tc, size, para.fValue.fVoidp, check);
+        Py_ssize_t buflen = cppjit::cpyrt::Utility::GetBuffer(pyobject, tc, size, para.fValue.fVoidp, check);
         if (!buflen) {
         // stuck here as it's the least common
-            if (CPyCppyy_PyLong_AsStrictInt(pyobject) == 0)
+            if (cpyrt_PyLong_AsStrictInt(pyobject) == 0)
                 para.fValue.fVoidp = nullptr;
             else {
                 PyErr_Format(PyExc_TypeError,     // ValueError?
@@ -461,10 +461,10 @@ static inline bool CArraySetArg(
 
 
 //- helper for implicit conversions ------------------------------------------
-static inline CPyCppyy::CPPInstance* ConvertImplicit(Cppyy::TCppScope_t klass,
-    PyObject* pyobject, CPyCppyy::Parameter& para, CPyCppyy::CallContext* ctxt, bool manage=true)
+static inline cppjit::cpyrt::CPPInstance* ConvertImplicit(cppjit::interop::TCppScope_t klass,
+    PyObject* pyobject, cppjit::cpyrt::Parameter& para, cppjit::cpyrt::CallContext* ctxt, bool manage=true)
 {
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
 
 // filter out copy and move constructors
     if (IsConstructor(ctxt->fFlags) && klass == ctxt->fCurScope && ctxt->GetSize() == 1)
@@ -519,13 +519,13 @@ static inline CPyCppyy::CPPInstance* ConvertImplicit(Cppyy::TCppScope_t klass,
 
 
 //- base converter implementation --------------------------------------------
-CPyCppyy::Converter::~Converter()
+cppjit::cpyrt::Converter::~Converter()
 {
     /* empty */
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::Converter::FromMemory(void*)
+PyObject* cppjit::cpyrt::Converter::FromMemory(void*)
 {
 // could happen if no derived class override
     PyErr_SetString(PyExc_TypeError, "C++ type cannot be converted from memory");
@@ -533,7 +533,7 @@ PyObject* CPyCppyy::Converter::FromMemory(void*)
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::Converter::ToMemory(PyObject*, void*, PyObject* /* ctxt */)
+bool cppjit::cpyrt::Converter::ToMemory(PyObject*, void*, PyObject* /* ctxt */)
 {
 // could happen if no derived class override
     PyErr_SetString(PyExc_TypeError, "C++ type cannot be converted to memory");
@@ -542,20 +542,20 @@ bool CPyCppyy::Converter::ToMemory(PyObject*, void*, PyObject* /* ctxt */)
 
 
 //- helper macro's -----------------------------------------------------------
-#define CPPYY_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)\
+#define CPPJIT_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)\
 /* convert <pyobject> to C++ 'type', set arg for call */                     \
     type val = (type)F2(pyobject);                                           \
     if (val == (type)-1 && PyErr_Occurred()) {                               \
         static PyTypeObject* ctypes_type = nullptr;                          \
         if (!ctypes_type) {                                                  \
-            auto error = CPyCppyy::Utility::FetchPyError();                  \
+            auto error = cppjit::cpyrt::Utility::FetchPyError();                  \
             ctypes_type = GetCTypesType(ct_##ctype);                         \
-            CPyCppyy::Utility::RestorePyError(error);                        \
+            cppjit::cpyrt::Utility::RestorePyError(error);                        \
         }                                                                    \
         if (Py_TYPE(pyobject) == ctypes_type) {                              \
             PyErr_Clear();                                                   \
-            val = *((type*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr);     \
-        } else if (pyobject == CPyCppyy::gDefaultObject) {                   \
+            val = *((type*)((cpyrt_tagCDataObject*)pyobject)->b_ptr);     \
+        } else if (pyobject == cppjit::cpyrt::gDefaultObject) {                   \
             PyErr_Clear();                                                   \
             val = (type)0;                                                   \
         } else                                                               \
@@ -565,18 +565,18 @@ bool CPyCppyy::Converter::ToMemory(PyObject*, void*, PyObject* /* ctxt */)
     para.fTypeCode = tc;                                                     \
     return true;
 
-#define CPPYY_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2) \
-PyObject* CPyCppyy::name##Converter::FromMemory(void* address)               \
+#define CPPJIT_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2) \
+PyObject* cppjit::cpyrt::name##Converter::FromMemory(void* address)               \
 {                                                                            \
     return F1((stype)*((type*)address));                                     \
 }                                                                            \
                                                                              \
-bool CPyCppyy::name##Converter::ToMemory(                                    \
+bool cppjit::cpyrt::name##Converter::ToMemory(                                    \
     PyObject* value, void* address, PyObject* /* ctxt */)                    \
 {                                                                            \
     type s = (type)F2(value);                                                \
     if (s == (type)-1 && PyErr_Occurred()) {                                 \
-        if (value == CPyCppyy::gDefaultObject) {                             \
+        if (value == cppjit::cpyrt::gDefaultObject) {                             \
             PyErr_Clear();                                                   \
             s = (type)0;                                                     \
         } else                                                               \
@@ -586,35 +586,35 @@ bool CPyCppyy::name##Converter::ToMemory(                                    \
     return true;                                                             \
 }
 
-#define CPPYY_IMPL_BASIC_CONVERTER_NI(name, type, stype, ctype, F1, F2, tc)  \
-bool CPyCppyy::name##Converter::SetArg(                                      \
+#define CPPJIT_IMPL_BASIC_CONVERTER_NI(name, type, stype, ctype, F1, F2, tc)  \
+bool cppjit::cpyrt::name##Converter::SetArg(                                      \
     PyObject* pyobject, Parameter& para, CallContext* ctxt)                  \
 {                                                                            \
     if (!StrictBool(pyobject, ctxt))                                         \
         return false;                                                        \
-    CPPYY_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)    \
+    CPPJIT_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)    \
 }                                                                            \
-CPPYY_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
+CPPJIT_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
 
-#define CPPYY_IMPL_BASIC_CONVERTER_IB(name, type, stype, ctype, F1, F2, tc)  \
-bool CPyCppyy::name##Converter::SetArg(                                      \
+#define CPPJIT_IMPL_BASIC_CONVERTER_IB(name, type, stype, ctype, F1, F2, tc)  \
+bool cppjit::cpyrt::name##Converter::SetArg(                                      \
     PyObject* pyobject, Parameter& para, CallContext* ctxt)                  \
 {                                                                            \
     if (!ImplicitBool(pyobject, ctxt))                                       \
         return false;                                                        \
-    CPPYY_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)    \
+    CPPJIT_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)    \
 }                                                                            \
-CPPYY_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
+CPPJIT_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
 
-#define CPPYY_IMPL_BASIC_CONVERTER_NB(name, type, stype, ctype, F1, F2, tc)  \
-bool CPyCppyy::name##Converter::SetArg(                                      \
+#define CPPJIT_IMPL_BASIC_CONVERTER_NB(name, type, stype, ctype, F1, F2, tc)  \
+bool cppjit::cpyrt::name##Converter::SetArg(                                      \
     PyObject* pyobject, Parameter& para, CallContext* /*ctxt*/)              \
 {                                                                            \
     if (PyBool_Check(pyobject))                                              \
         return false;                                                        \
-    CPPYY_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)    \
+    CPPJIT_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)    \
 }                                                                            \
-CPPYY_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
+CPPJIT_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
 
 //----------------------------------------------------------------------------
 static inline int ExtractChar(PyObject* pyobject, const char* tname, int low, int high)
@@ -626,13 +626,13 @@ static inline int ExtractChar(PyObject* pyobject, const char* tname, int low, in
         else
             PyErr_Format(PyExc_ValueError, "%s expected, got bytes of size " PY_SSIZE_T_FORMAT,
                 tname, PyBytes_GET_SIZE(pyobject));
-    } else if (CPyCppyy_PyText_Check(pyobject)) {
-        if (CPyCppyy_PyText_GET_SIZE(pyobject) == 1)
-            lchar = (int)(CPyCppyy_PyText_AsString(pyobject)[0]);
+    } else if (cpyrt_PyText_Check(pyobject)) {
+        if (cpyrt_PyText_GET_SIZE(pyobject) == 1)
+            lchar = (int)(cpyrt_PyText_AsString(pyobject)[0]);
         else
             PyErr_Format(PyExc_ValueError, "%s expected, got str of size " PY_SSIZE_T_FORMAT,
-                tname, CPyCppyy_PyText_GET_SIZE(pyobject));
-    } else if (pyobject == CPyCppyy::gDefaultObject) {
+                tname, cpyrt_PyText_GET_SIZE(pyobject));
+    } else if (pyobject == cppjit::cpyrt::gDefaultObject) {
         lchar = (int)'\0';
     } else if (!PyFloat_Check(pyobject)) {   // don't allow truncating conversion
         lchar = (int)PyLong_AsLong(pyobject);
@@ -650,8 +650,8 @@ static inline int ExtractChar(PyObject* pyobject, const char* tname, int low, in
 }
 
 //----------------------------------------------------------------------------
-#define CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(name, ctype)                     \
-PyObject* CPyCppyy::name##RefConverter::FromMemory(void* ptr)                \
+#define CPPJIT_IMPL_REFCONVERTER_FROM_MEMORY(name, ctype)                     \
+PyObject* cppjit::cpyrt::name##RefConverter::FromMemory(void* ptr)                \
 {                                                                            \
 /* convert a reference to int to Python through ctypes pointer object */     \
     PyTypeObject* ctypes_type = GetCTypesType(ct_##ctype);                   \
@@ -660,19 +660,19 @@ PyObject* CPyCppyy::name##RefConverter::FromMemory(void* ptr)                \
         return nullptr;                                                      \
     }                                                                        \
     PyObject* ref = ctypes_type->tp_new(ctypes_type, nullptr, nullptr);      \
-    ((CPyCppyy_tagCDataObject*)ref)->b_ptr = (char*)ptr;                     \
-    ((CPyCppyy_tagCDataObject*)ref)->b_needsfree = 0;                        \
+    ((cpyrt_tagCDataObject*)ref)->b_ptr = (char*)ptr;                     \
+    ((cpyrt_tagCDataObject*)ref)->b_needsfree = 0;                        \
     return ref;                                                              \
 }
 
 //----------------------------------------------------------------------------
-#define CPPYY_IMPL_BASIC_CONST_REFCONVERTER(name, type, ctype, F1)           \
-bool CPyCppyy::Const##name##RefConverter::SetArg(                            \
+#define CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(name, type, ctype, F1)           \
+bool cppjit::cpyrt::Const##name##RefConverter::SetArg(                            \
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)            \
 {                                                                            \
     type val = (type)F1(pyobject);                                           \
     if (val == (type)-1 && PyErr_Occurred()) {                               \
-        if (pyobject == CPyCppyy::gDefaultObject) {                          \
+        if (pyobject == cppjit::cpyrt::gDefaultObject) {                          \
             PyErr_Clear();                                                   \
             val = (type)0;                                                   \
         } else                                                               \
@@ -683,11 +683,11 @@ bool CPyCppyy::Const##name##RefConverter::SetArg(                            \
     para.fTypeCode = 'r';                                                    \
     return true;                                                             \
 }                                                                            \
-CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(Const##name, ctype)
+CPPJIT_IMPL_REFCONVERTER_FROM_MEMORY(Const##name, ctype)
 
 //----------------------------------------------------------------------------
-#define CPPYY_IMPL_BASIC_CONST_CHAR_REFCONVERTER(name, type, ctype, low, high)\
-bool CPyCppyy::Const##name##RefConverter::SetArg(                            \
+#define CPPJIT_IMPL_BASIC_CONST_CHAR_REFCONVERTER(name, type, ctype, low, high)\
+bool cppjit::cpyrt::Const##name##RefConverter::SetArg(                            \
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)            \
 {                                                                            \
 /* convert <pyobject> to C++ <<type>>, set arg for call, allow int -> char */\
@@ -698,12 +698,12 @@ bool CPyCppyy::Const##name##RefConverter::SetArg(                            \
     para.fTypeCode = 'l';                                                    \
     return true;                                                             \
 }                                                                            \
-CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(Const##name, ctype)
+CPPJIT_IMPL_REFCONVERTER_FROM_MEMORY(Const##name, ctype)
 
 
 //----------------------------------------------------------------------------
-#define CPPYY_IMPL_BASIC_CHAR_CONVERTER(name, type, low, high)               \
-bool CPyCppyy::name##Converter::SetArg(                                      \
+#define CPPJIT_IMPL_BASIC_CHAR_CONVERTER(name, type, low, high)               \
+bool cppjit::cpyrt::name##Converter::SetArg(                                      \
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)            \
 {                                                                            \
 /* convert <pyobject> to C++ <<type>>, set arg for call, allow int -> char */\
@@ -715,13 +715,13 @@ bool CPyCppyy::name##Converter::SetArg(                                      \
     return true;                                                             \
 }                                                                            \
                                                                              \
-PyObject* CPyCppyy::name##Converter::FromMemory(void* address)               \
+PyObject* cppjit::cpyrt::name##Converter::FromMemory(void* address)               \
 {                                                                            \
     /* return char in "native" str type as that's more natural in use */     \
-    return CPyCppyy_PyText_FromFormat("%c", *((type*)address));              \
+    return cpyrt_PyText_FromFormat("%c", *((type*)address));              \
 }                                                                            \
                                                                              \
-bool CPyCppyy::name##Converter::ToMemory(                                    \
+bool cppjit::cpyrt::name##Converter::ToMemory(                                    \
     PyObject* value, void* address, PyObject* /* ctxt */)                    \
 {                                                                            \
     Py_ssize_t len;                                                          \
@@ -729,7 +729,7 @@ bool CPyCppyy::name##Converter::ToMemory(                                    \
     if (PyBytes_Check(value))                                                \
         PyBytes_AsStringAndSize(value, (char**)&cstr, &len);                 \
     else                                                                     \
-        cstr = CPyCppyy_PyText_AsStringAndSize(value, &len);                 \
+        cstr = cpyrt_PyText_AsStringAndSize(value, &len);                 \
     if (cstr) {                                                              \
         if (len != 1) {                                                      \
             PyErr_Format(PyExc_TypeError, #type" expected, got string of size %zd", len);\
@@ -740,7 +740,7 @@ bool CPyCppyy::name##Converter::ToMemory(                                    \
         PyErr_Clear();                                                       \
         long l = PyLong_AsLong(value);                                       \
         if (l == -1 && PyErr_Occurred()) {                                   \
-            if (value == CPyCppyy::gDefaultObject) {                         \
+            if (value == cppjit::cpyrt::gDefaultObject) {                         \
                 PyErr_Clear();                                               \
                 l = (long)0;                                                 \
             } else                                                           \
@@ -758,16 +758,16 @@ bool CPyCppyy::name##Converter::ToMemory(                                    \
 
 
 //- converters for built-ins -------------------------------------------------
-CPPYY_IMPL_BASIC_CONVERTER_IB(Long, long, long, c_long, PyLong_FromLong, CPyCppyy_PyLong_AsStrictLong, 'l')
+CPPJIT_IMPL_BASIC_CONVERTER_IB(Long, long, long, c_long, PyLong_FromLong, cpyrt_PyLong_AsStrictLong, 'l')
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::LongRefConverter::SetArg(
+bool cppjit::cpyrt::LongRefConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // convert <pyobject> to C++ long&, set arg for call
 
     if (Py_TYPE(pyobject) == GetCTypesType(ct_c_long)) {
-        para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;
+        para.fValue.fVoidp = (void*)((cpyrt_tagCDataObject*)pyobject)->b_ptr;
         para.fTypeCode = 'V';
         return true;
     }
@@ -782,29 +782,29 @@ bool CPyCppyy::LongRefConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-CPPYY_IMPL_BASIC_CONST_CHAR_REFCONVERTER(Char,  char,          c_char,  CHAR_MIN,  CHAR_MAX)
-CPPYY_IMPL_BASIC_CONST_CHAR_REFCONVERTER(UChar, unsigned char, c_uchar,        0, UCHAR_MAX)
+CPPJIT_IMPL_BASIC_CONST_CHAR_REFCONVERTER(Char,  char,          c_char,  CHAR_MIN,  CHAR_MAX)
+CPPJIT_IMPL_BASIC_CONST_CHAR_REFCONVERTER(UChar, unsigned char, c_uchar,        0, UCHAR_MAX)
 
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(Bool,   bool,           c_bool,      CPyCppyy_PyLong_AsBool)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(Int8,   int8_t,         c_int8,      CPyCppyy_PyLong_AsInt8)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(UInt8,  uint8_t,        c_uint8,     CPyCppyy_PyLong_AsUInt8)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(Short,  short,          c_short,     CPyCppyy_PyLong_AsShort)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(UShort, unsigned short, c_ushort,    CPyCppyy_PyLong_AsUShort)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(Int,    int,            c_int,       CPyCppyy_PyLong_AsStrictInt)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(UInt,   unsigned int,   c_uint,      PyLongOrInt_AsULong)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(Long,   long,           c_long,      CPyCppyy_PyLong_AsStrictLong)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(ULong,  unsigned long,  c_ulong,     PyLongOrInt_AsULong)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(LLong,  PY_LONG_LONG,   c_longlong,  CPyCppyy_PyLong_AsStrictLongLong)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(ULLong, PY_ULONG_LONG,  c_ulonglong, PyLongOrInt_AsULong64)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(Bool,   bool,           c_bool,      cpyrt_PyLong_AsBool)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(Int8,   int8_t,         c_int8,      cpyrt_PyLong_AsInt8)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(UInt8,  uint8_t,        c_uint8,     cpyrt_PyLong_AsUInt8)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(Short,  short,          c_short,     cpyrt_PyLong_AsShort)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(UShort, unsigned short, c_ushort,    cpyrt_PyLong_AsUShort)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(Int,    int,            c_int,       cpyrt_PyLong_AsStrictInt)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(UInt,   unsigned int,   c_uint,      PyLongOrInt_AsULong)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(Long,   long,           c_long,      cpyrt_PyLong_AsStrictLong)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(ULong,  unsigned long,  c_ulong,     PyLongOrInt_AsULong)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(LLong,  PY_LONG_LONG,   c_longlong,  cpyrt_PyLong_AsStrictLongLong)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(ULLong, PY_ULONG_LONG,  c_ulonglong, PyLongOrInt_AsULong64)
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::IntRefConverter::SetArg(
+bool cppjit::cpyrt::IntRefConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // convert <pyobject> to C++ (pseudo)int&, set arg for call
 
     if (Py_TYPE(pyobject) == GetCTypesType(ct_c_int)) {
-        para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;
+        para.fValue.fVoidp = (void*)((cpyrt_tagCDataObject*)pyobject)->b_ptr;
         para.fTypeCode = 'V';
         return true;
     }
@@ -821,13 +821,13 @@ bool CPyCppyy::IntRefConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-#define CPPYY_IMPL_REFCONVERTER(name, ctype, type, code)                     \
-bool CPyCppyy::name##RefConverter::SetArg(                                   \
+#define CPPJIT_IMPL_REFCONVERTER(name, ctype, type, code)                     \
+bool cppjit::cpyrt::name##RefConverter::SetArg(                                   \
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)            \
 {                                                                            \
 /* convert a reference to int to Python through ctypes pointer object */     \
     if (Py_TYPE(pyobject) == GetCTypesType(ct_##ctype)) {                    \
-        para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;\
+        para.fValue.fVoidp = (void*)((cpyrt_tagCDataObject*)pyobject)->b_ptr;\
         para.fTypeCode = 'V';                                                \
         return true;                                                         \
     }                                                                        \
@@ -839,47 +839,47 @@ bool CPyCppyy::name##RefConverter::SetArg(                                   \
     para.fTypeCode = 'V';                                                    \
     return res;                                                              \
 }                                                                            \
-CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(name, ctype)
-
-CPPYY_IMPL_REFCONVERTER(Bool,    c_bool,       bool,               '?');
-CPPYY_IMPL_REFCONVERTER(Char,    c_char,       char,               'b');
-CPPYY_IMPL_REFCONVERTER(WChar,   c_wchar,      wchar_t,            'u');
-CPPYY_IMPL_REFCONVERTER(Char16,  c_uint16,     char16_t,           'H');
-CPPYY_IMPL_REFCONVERTER(Char32,  c_uint32,     char32_t,           'I');
-CPPYY_IMPL_REFCONVERTER(SChar,   c_byte,       signed char,        'b');
-CPPYY_IMPL_REFCONVERTER(UChar,   c_ubyte,      unsigned char,      'B');
-CPPYY_IMPL_REFCONVERTER(Int8,    c_int8,       int8_t,             'b');
-CPPYY_IMPL_REFCONVERTER(UInt8,   c_uint8,      uint8_t,            'B');
-CPPYY_IMPL_REFCONVERTER(Short,   c_short,      short,              'h');
-CPPYY_IMPL_REFCONVERTER(UShort,  c_ushort,     unsigned short,     'H');
-CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(Int, c_int);
-CPPYY_IMPL_REFCONVERTER(UInt,    c_uint,       unsigned int,       'I');
-CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(Long, c_long);
-CPPYY_IMPL_REFCONVERTER(ULong,   c_ulong,      unsigned long,      'L');
-CPPYY_IMPL_REFCONVERTER(LLong,   c_longlong,   long long,          'q');
-CPPYY_IMPL_REFCONVERTER(ULLong,  c_ulonglong,  unsigned long long, 'Q');
-CPPYY_IMPL_REFCONVERTER(Float,   c_float,      float,              'f');
-CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(Double, c_double);
-CPPYY_IMPL_REFCONVERTER(LDouble, c_longdouble, PY_LONG_DOUBLE,     'g');
+CPPJIT_IMPL_REFCONVERTER_FROM_MEMORY(name, ctype)
+
+CPPJIT_IMPL_REFCONVERTER(Bool,    c_bool,       bool,               '?');
+CPPJIT_IMPL_REFCONVERTER(Char,    c_char,       char,               'b');
+CPPJIT_IMPL_REFCONVERTER(WChar,   c_wchar,      wchar_t,            'u');
+CPPJIT_IMPL_REFCONVERTER(Char16,  c_uint16,     char16_t,           'H');
+CPPJIT_IMPL_REFCONVERTER(Char32,  c_uint32,     char32_t,           'I');
+CPPJIT_IMPL_REFCONVERTER(SChar,   c_byte,       signed char,        'b');
+CPPJIT_IMPL_REFCONVERTER(UChar,   c_ubyte,      unsigned char,      'B');
+CPPJIT_IMPL_REFCONVERTER(Int8,    c_int8,       int8_t,             'b');
+CPPJIT_IMPL_REFCONVERTER(UInt8,   c_uint8,      uint8_t,            'B');
+CPPJIT_IMPL_REFCONVERTER(Short,   c_short,      short,              'h');
+CPPJIT_IMPL_REFCONVERTER(UShort,  c_ushort,     unsigned short,     'H');
+CPPJIT_IMPL_REFCONVERTER_FROM_MEMORY(Int, c_int);
+CPPJIT_IMPL_REFCONVERTER(UInt,    c_uint,       unsigned int,       'I');
+CPPJIT_IMPL_REFCONVERTER_FROM_MEMORY(Long, c_long);
+CPPJIT_IMPL_REFCONVERTER(ULong,   c_ulong,      unsigned long,      'L');
+CPPJIT_IMPL_REFCONVERTER(LLong,   c_longlong,   long long,          'q');
+CPPJIT_IMPL_REFCONVERTER(ULLong,  c_ulonglong,  unsigned long long, 'Q');
+CPPJIT_IMPL_REFCONVERTER(Float,   c_float,      float,              'f');
+CPPJIT_IMPL_REFCONVERTER_FROM_MEMORY(Double, c_double);
+CPPJIT_IMPL_REFCONVERTER(LDouble, c_longdouble, PY_LONG_DOUBLE,     'g');
 
 
 //----------------------------------------------------------------------------
 // convert <pyobject> to C++ bool, allow int/long -> bool, set arg for call
-CPPYY_IMPL_BASIC_CONVERTER_NI(
-    Bool, bool, long, c_bool, PyBool_FromLong, CPyCppyy_PyLong_AsBool, 'l')
+CPPJIT_IMPL_BASIC_CONVERTER_NI(
+    Bool, bool, long, c_bool, PyBool_FromLong, cpyrt_PyLong_AsBool, 'l')
 
 //----------------------------------------------------------------------------
-CPPYY_IMPL_BASIC_CHAR_CONVERTER(Char,  char,          CHAR_MIN,  CHAR_MAX)
-CPPYY_IMPL_BASIC_CHAR_CONVERTER(UChar, unsigned char,        0, UCHAR_MAX)
+CPPJIT_IMPL_BASIC_CHAR_CONVERTER(Char,  char,          CHAR_MIN,  CHAR_MAX)
+CPPJIT_IMPL_BASIC_CHAR_CONVERTER(UChar, unsigned char,        0, UCHAR_MAX)
 
-PyObject* CPyCppyy::SCharAsIntConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::SCharAsIntConverter::FromMemory(void* address)
 {
 // special case to be used with arrays: return a Python int instead of str
 // (following the same convention as module array.array)
     return PyInt_FromLong((long)*((signed char*)address));
 }
 
-PyObject* CPyCppyy::UCharAsIntConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::UCharAsIntConverter::FromMemory(void* address)
 {
 // special case to be used with arrays: return a Python int instead of str
 // (following the same convention as module array.array)
@@ -887,16 +887,16 @@ PyObject* CPyCppyy::UCharAsIntConverter::FromMemory(void* address)
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::WCharConverter::SetArg(
+bool cppjit::cpyrt::WCharConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // convert <pyobject> to C++ <wchar_t>, set arg for call
-    if (!PyUnicode_Check(pyobject) || CPyCppyy_PyUnicode_GET_SIZE(pyobject) != 1) {
+    if (!PyUnicode_Check(pyobject) || cpyrt_PyUnicode_GET_SIZE(pyobject) != 1) {
         PyErr_SetString(PyExc_ValueError, "single wchar_t character expected");
         return false;
     }
     wchar_t val;
-    Py_ssize_t res = CPyCppyy_PyUnicode_AsWideChar(pyobject, &val, 1);
+    Py_ssize_t res = cpyrt_PyUnicode_AsWideChar(pyobject, &val, 1);
     if (res == -1)
         return false;
     para.fValue.fLong = (long)val;
@@ -904,19 +904,19 @@ bool CPyCppyy::WCharConverter::SetArg(
     return true;
 }
 
-PyObject* CPyCppyy::WCharConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::WCharConverter::FromMemory(void* address)
 {
     return PyUnicode_FromWideChar((const wchar_t*)address, 1);
 }
 
-bool CPyCppyy::WCharConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::WCharConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
-    if (!PyUnicode_Check(value) || CPyCppyy_PyUnicode_GET_SIZE(value) != 1) {
+    if (!PyUnicode_Check(value) || cpyrt_PyUnicode_GET_SIZE(value) != 1) {
         PyErr_SetString(PyExc_ValueError, "single wchar_t character expected");
         return false;
     }
     wchar_t val;
-    Py_ssize_t res = CPyCppyy_PyUnicode_AsWideChar(value, &val, 1);
+    Py_ssize_t res = cpyrt_PyUnicode_AsWideChar(value, &val, 1);
     if (res == -1)
         return false;
     *((wchar_t*)address) = val;
@@ -924,11 +924,11 @@ bool CPyCppyy::WCharConverter::ToMemory(PyObject* value, void* address, PyObject
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::Char16Converter::SetArg(
+bool cppjit::cpyrt::Char16Converter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // convert <pyobject> to C++ <char16_t>, set arg for call
-    if (!PyUnicode_Check(pyobject) || CPyCppyy_PyUnicode_GET_SIZE(pyobject) != 1) {
+    if (!PyUnicode_Check(pyobject) || cpyrt_PyUnicode_GET_SIZE(pyobject) != 1) {
         PyErr_SetString(PyExc_ValueError, "single char16_t character expected");
         return false;
     }
@@ -943,14 +943,14 @@ bool CPyCppyy::Char16Converter::SetArg(
     return true;
 }
 
-PyObject* CPyCppyy::Char16Converter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::Char16Converter::FromMemory(void* address)
 {
     return PyUnicode_DecodeUTF16((const char*)address, sizeof(char16_t), nullptr, nullptr);
 }
 
-bool CPyCppyy::Char16Converter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::Char16Converter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
-    if (!PyUnicode_Check(value) || CPyCppyy_PyUnicode_GET_SIZE(value) != 1) {
+    if (!PyUnicode_Check(value) || cpyrt_PyUnicode_GET_SIZE(value) != 1) {
         PyErr_SetString(PyExc_ValueError, "single char16_t character expected");
         return false;
     }
@@ -964,11 +964,11 @@ bool CPyCppyy::Char16Converter::ToMemory(PyObject* value, void* address, PyObjec
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::Char32Converter::SetArg(
+bool cppjit::cpyrt::Char32Converter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // convert <pyobject> to C++ <char32_t>, set arg for call
-    if (!PyUnicode_Check(pyobject) || 2 < CPyCppyy_PyUnicode_GET_SIZE(pyobject)) {
+    if (!PyUnicode_Check(pyobject) || 2 < cpyrt_PyUnicode_GET_SIZE(pyobject)) {
         PyErr_SetString(PyExc_ValueError, "single char32_t character expected");
         return false;
     }
@@ -983,14 +983,14 @@ bool CPyCppyy::Char32Converter::SetArg(
     return true;
 }
 
-PyObject* CPyCppyy::Char32Converter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::Char32Converter::FromMemory(void* address)
 {
     return PyUnicode_DecodeUTF32((const char*)address, sizeof(char32_t), nullptr, nullptr);
 }
 
-bool CPyCppyy::Char32Converter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::Char32Converter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
-    if (!PyUnicode_Check(value) || 2 < CPyCppyy_PyUnicode_GET_SIZE(value)) {
+    if (!PyUnicode_Check(value) || 2 < cpyrt_PyUnicode_GET_SIZE(value)) {
         PyErr_SetString(PyExc_ValueError, "single char32_t character expected");
         return false;
     }
@@ -1004,19 +1004,19 @@ bool CPyCppyy::Char32Converter::ToMemory(PyObject* value, void* address, PyObjec
 }
 
 //----------------------------------------------------------------------------
-CPPYY_IMPL_BASIC_CONVERTER_IB(
-    Int8,  int8_t,  long, c_int8, PyInt_FromLong, CPyCppyy_PyLong_AsInt8,  'l')
-CPPYY_IMPL_BASIC_CONVERTER_IB(
-    UInt8, uint8_t, long, c_uint8, PyInt_FromLong, CPyCppyy_PyLong_AsUInt8, 'l')
-CPPYY_IMPL_BASIC_CONVERTER_IB(
-    Short, short, long, c_short, PyInt_FromLong, CPyCppyy_PyLong_AsShort, 'l')
-CPPYY_IMPL_BASIC_CONVERTER_IB(
-    UShort, unsigned short, long, c_ushort, PyInt_FromLong, CPyCppyy_PyLong_AsUShort, 'l')
-CPPYY_IMPL_BASIC_CONVERTER_IB(
-    Int, int, long, c_uint, PyInt_FromLong, CPyCppyy_PyLong_AsStrictInt, 'l')
+CPPJIT_IMPL_BASIC_CONVERTER_IB(
+    Int8,  int8_t,  long, c_int8, PyInt_FromLong, cpyrt_PyLong_AsInt8,  'l')
+CPPJIT_IMPL_BASIC_CONVERTER_IB(
+    UInt8, uint8_t, long, c_uint8, PyInt_FromLong, cpyrt_PyLong_AsUInt8, 'l')
+CPPJIT_IMPL_BASIC_CONVERTER_IB(
+    Short, short, long, c_short, PyInt_FromLong, cpyrt_PyLong_AsShort, 'l')
+CPPJIT_IMPL_BASIC_CONVERTER_IB(
+    UShort, unsigned short, long, c_ushort, PyInt_FromLong, cpyrt_PyLong_AsUShort, 'l')
+CPPJIT_IMPL_BASIC_CONVERTER_IB(
+    Int, int, long, c_uint, PyInt_FromLong, cpyrt_PyLong_AsStrictInt, 'l')
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::ULongConverter::SetArg(
+bool cppjit::cpyrt::ULongConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ unsigned long, set arg for call
@@ -1030,18 +1030,18 @@ bool CPyCppyy::ULongConverter::SetArg(
     return true;
 }
 
-PyObject* CPyCppyy::ULongConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::ULongConverter::FromMemory(void* address)
 {
 // construct python object from C++ unsigned long read at <address>
     return PyLong_FromUnsignedLong(*((unsigned long*)address));
 }
 
-bool CPyCppyy::ULongConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::ULongConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // convert <value> to C++ unsigned long, write it at <address>
     unsigned long u = PyLongOrInt_AsULong(value);
     if (u == (unsigned long)-1 && PyErr_Occurred()) {
-        if (value == CPyCppyy::gDefaultObject) {
+        if (value == cppjit::cpyrt::gDefaultObject) {
             PyErr_Clear();
             u = (unsigned long)0;
         } else
@@ -1052,13 +1052,13 @@ bool CPyCppyy::ULongConverter::ToMemory(PyObject* value, void* address, PyObject
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::UIntConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::UIntConverter::FromMemory(void* address)
 {
 // construct python object from C++ unsigned int read at <address>
     return PyLong_FromUnsignedLong(*((unsigned int*)address));
 }
 
-bool CPyCppyy::UIntConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::UIntConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // convert <value> to C++ unsigned int, write it at <address>
     unsigned long u = PyLongOrInt_AsULong(value);
@@ -1075,19 +1075,19 @@ bool CPyCppyy::UIntConverter::ToMemory(PyObject* value, void* address, PyObject*
 }
 
 //- floating point converters ------------------------------------------------
-CPPYY_IMPL_BASIC_CONVERTER_NB(
+CPPJIT_IMPL_BASIC_CONVERTER_NB(
     Float,  float,  double, c_float,  PyFloat_FromDouble, PyFloat_AsDouble, 'f')
-CPPYY_IMPL_BASIC_CONVERTER_NB(
+CPPJIT_IMPL_BASIC_CONVERTER_NB(
     Double, double, double, c_double, PyFloat_FromDouble, PyFloat_AsDouble, 'd')
 
-CPPYY_IMPL_BASIC_CONVERTER_NB(
+CPPJIT_IMPL_BASIC_CONVERTER_NB(
     LDouble, PY_LONG_DOUBLE, PY_LONG_DOUBLE, c_longdouble, PyFloat_FromDouble, PyFloat_AsDouble, 'g')
 
-CPyCppyy::ComplexDConverter::ComplexDConverter(bool keepControl) :
-    InstanceConverter(Cppyy::GetFullScope("std::complex<double>"), keepControl) {}
+cppjit::cpyrt::ComplexDConverter::ComplexDConverter(bool keepControl) :
+    InstanceConverter(cppjit::interop::GetFullScope("std::complex<double>"), keepControl) {}
 
 // special case for std::complex<double>, maps it to/from Python's complex
-bool CPyCppyy::ComplexDConverter::SetArg(
+bool cppjit::cpyrt::ComplexDConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
     const Py_complex& pc = PyComplex_AsCComplex(pyobject);
@@ -1102,13 +1102,13 @@ bool CPyCppyy::ComplexDConverter::SetArg(
     return this->InstanceConverter::SetArg(pyobject, para, ctxt);
 }
 
-PyObject* CPyCppyy::ComplexDConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::ComplexDConverter::FromMemory(void* address)
 {
     std::complex<double>* dc = (std::complex<double>*)address;
     return PyComplex_FromDoubles(dc->real(), dc->imag());
 }
 
-bool CPyCppyy::ComplexDConverter::ToMemory(PyObject* value, void* address, PyObject* ctxt)
+bool cppjit::cpyrt::ComplexDConverter::ToMemory(PyObject* value, void* address, PyObject* ctxt)
 {
     const Py_complex& pc = PyComplex_AsCComplex(value);
     if (pc.real != -1.0 || !PyErr_Occurred()) {
@@ -1121,13 +1121,13 @@ bool CPyCppyy::ComplexDConverter::ToMemory(PyObject* value, void* address, PyObj
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::DoubleRefConverter::SetArg(
+bool cppjit::cpyrt::DoubleRefConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // convert <pyobject> to C++ double&, set arg for call
 
     if (Py_TYPE(pyobject) == GetCTypesType(ct_c_double)) {
-        para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;
+        para.fValue.fVoidp = (void*)((cpyrt_tagCDataObject*)pyobject)->b_ptr;
         para.fTypeCode = 'V';
         return true;
     }
@@ -1144,12 +1144,12 @@ bool CPyCppyy::DoubleRefConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(Float,   float,          c_float,      PyFloat_AsDouble)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(Double,  double,         c_double,     PyFloat_AsDouble)
-CPPYY_IMPL_BASIC_CONST_REFCONVERTER(LDouble, PY_LONG_DOUBLE, c_longdouble, PyFloat_AsDouble)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(Float,   float,          c_float,      PyFloat_AsDouble)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(Double,  double,         c_double,     PyFloat_AsDouble)
+CPPJIT_IMPL_BASIC_CONST_REFCONVERTER(LDouble, PY_LONG_DOUBLE, c_longdouble, PyFloat_AsDouble)
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::VoidConverter::SetArg(PyObject*, Parameter&, CallContext*)
+bool cppjit::cpyrt::VoidConverter::SetArg(PyObject*, Parameter&, CallContext*)
 {
 // can't happen (unless a type is mapped wrongly), but implemented for completeness
     PyErr_SetString(PyExc_SystemError, "void/unknown arguments can\'t be set");
@@ -1157,32 +1157,32 @@ bool CPyCppyy::VoidConverter::SetArg(PyObject*, Parameter&, CallContext*)
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::LLongConverter::SetArg(
+bool cppjit::cpyrt::LLongConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ long long, set arg for call
     if (!ImplicitBool(pyobject, ctxt))
         return false;
 
-    para.fValue.fLLong = CPyCppyy_PyLong_AsStrictLongLong(pyobject);
+    para.fValue.fLLong = cpyrt_PyLong_AsStrictLongLong(pyobject);
     if (PyErr_Occurred())
         return false;
     para.fTypeCode = 'q';
     return true;
 }
 
-PyObject* CPyCppyy::LLongConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::LLongConverter::FromMemory(void* address)
 {
 // construct python object from C++ long long read at <address>
     return PyLong_FromLongLong(*(PY_LONG_LONG*)address);
 }
 
-bool CPyCppyy::LLongConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::LLongConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // convert <value> to C++ long long, write it at <address>
     PY_LONG_LONG ll = PyLong_AsLongLong(value);
     if (ll == -1 && PyErr_Occurred()) {
-        if (value == CPyCppyy::gDefaultObject) {
+        if (value == cppjit::cpyrt::gDefaultObject) {
             PyErr_Clear();
             ll = (PY_LONG_LONG)0;
         } else
@@ -1193,7 +1193,7 @@ bool CPyCppyy::LLongConverter::ToMemory(PyObject* value, void* address, PyObject
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::ULLongConverter::SetArg(
+bool cppjit::cpyrt::ULLongConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ unsigned long long, set arg for call
@@ -1207,18 +1207,18 @@ bool CPyCppyy::ULLongConverter::SetArg(
     return true;
 }
 
-PyObject* CPyCppyy::ULLongConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::ULLongConverter::FromMemory(void* address)
 {
 // construct python object from C++ unsigned long long read at <address>
     return PyLong_FromUnsignedLongLong(*(PY_ULONG_LONG*)address);
 }
 
-bool CPyCppyy::ULLongConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::ULLongConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // convert <value> to C++ unsigned long long, write it at <address>
     PY_ULONG_LONG ull = PyLongOrInt_AsULong64(value);
     if (PyErr_Occurred()) {
-        if (value == CPyCppyy::gDefaultObject) {
+        if (value == cppjit::cpyrt::gDefaultObject) {
             PyErr_Clear();
             ull = (PY_ULONG_LONG)0;
         } else
@@ -1229,22 +1229,22 @@ bool CPyCppyy::ULLongConverter::ToMemory(PyObject* value, void* address, PyObjec
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::CStringConverter::SetArg(
+bool cppjit::cpyrt::CStringConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // construct a new string and copy it in new memory
     Py_ssize_t len;
-    const char* cstr = CPyCppyy_PyText_AsStringAndSize(pyobject, &len);
+    const char* cstr = cpyrt_PyText_AsStringAndSize(pyobject, &len);
     if (!cstr) {
     // special case: allow ctypes c_char_p
-        auto error = CPyCppyy::Utility::FetchPyError();
+        auto error = cppjit::cpyrt::Utility::FetchPyError();
         if (Py_TYPE(pyobject) == GetCTypesType(ct_c_char_p)) {
             SetLifeLine(ctxt->fPyContext, pyobject, (intptr_t)this);
-            para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;
+            para.fValue.fVoidp = (void*)((cpyrt_tagCDataObject*)pyobject)->b_ptr;
             para.fTypeCode = 'V';
             return true;
         }
-        CPyCppyy::Utility::RestorePyError(error);
+        cppjit::cpyrt::Utility::RestorePyError(error);
         return false;
     }
 
@@ -1268,18 +1268,18 @@ bool CPyCppyy::CStringConverter::SetArg(
     return true;
 }
 
-PyObject* CPyCppyy::CStringConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::CStringConverter::FromMemory(void* address)
 {
 // construct python object from C++ const char* read at <address>
     if (address && *(void**)address) {
         if (fMaxSize != std::string::npos)       // need to prevent reading beyond boundary
-            return CPyCppyy_PyText_FromStringAndSize(*(char**)address, (Py_ssize_t)fMaxSize);
+            return cpyrt_PyText_FromStringAndSize(*(char**)address, (Py_ssize_t)fMaxSize);
 
         if (*(void**)address == (void*)fBuffer.data())     // if we're buffering, we know the size
-            return CPyCppyy_PyText_FromStringAndSize((char*)fBuffer.data(), fBuffer.size());
+            return cpyrt_PyText_FromStringAndSize((char*)fBuffer.data(), fBuffer.size());
 
     // no idea about lentgth: cut on \0
-        return CPyCppyy_PyText_FromString(*(char**)address);
+        return cpyrt_PyText_FromString(*(char**)address);
     }
 
 // empty string in case there's no address
@@ -1287,11 +1287,11 @@ PyObject* CPyCppyy::CStringConverter::FromMemory(void* address)
     return PyStrings::gEmptyString;
 }
 
-bool CPyCppyy::CStringConverter::ToMemory(PyObject* value, void* address, PyObject* ctxt)
+bool cppjit::cpyrt::CStringConverter::ToMemory(PyObject* value, void* address, PyObject* ctxt)
 {
 // convert <value> to C++ const char*, write it at <address>
     Py_ssize_t len;
-    const char* cstr = CPyCppyy_PyText_AsStringAndSize(value, &len);
+    const char* cstr = cpyrt_PyText_AsStringAndSize(value, &len);
     if (!cstr) return false;
 
 // verify (too long string will cause truncation, no crash)
@@ -1330,7 +1330,7 @@ bool CPyCppyy::CStringConverter::ToMemory(PyObject* value, void* address, PyObje
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::WCStringConverter::SetArg(
+bool cppjit::cpyrt::WCStringConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // construct a new string and copy it in new memory
@@ -1339,7 +1339,7 @@ bool CPyCppyy::WCStringConverter::SetArg(
         return false;
 
     fBuffer = (wchar_t*)realloc(fBuffer, sizeof(wchar_t)*(len+1));
-    Py_ssize_t res = CPyCppyy_PyUnicode_AsWideChar(pyobject, fBuffer, len);
+    Py_ssize_t res = cpyrt_PyUnicode_AsWideChar(pyobject, fBuffer, len);
     if (res == -1)
         return false;   // could free the buffer here
 
@@ -1350,7 +1350,7 @@ bool CPyCppyy::WCStringConverter::SetArg(
     return true;
 }
 
-PyObject* CPyCppyy::WCStringConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::WCStringConverter::FromMemory(void* address)
 {
 // construct python object from C++ wchar_t* read at <address>
     if (address && *(wchar_t**)address) {
@@ -1365,7 +1365,7 @@ PyObject* CPyCppyy::WCStringConverter::FromMemory(void* address)
     return PyUnicode_FromWideChar(&w, 0);
 }
 
-bool CPyCppyy::WCStringConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::WCStringConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // convert <value> to C++ wchar_t*, write it at <address>
     Py_ssize_t len = PyUnicode_GetSize(value);
@@ -1379,18 +1379,18 @@ bool CPyCppyy::WCStringConverter::ToMemory(PyObject* value, void* address, PyObj
 
     Py_ssize_t res = -1;
     if (fMaxSize != std::wstring::npos)
-        res = CPyCppyy_PyUnicode_AsWideChar(value, *(wchar_t**)address, (Py_ssize_t)fMaxSize);
+        res = cpyrt_PyUnicode_AsWideChar(value, *(wchar_t**)address, (Py_ssize_t)fMaxSize);
     else
     // coverity[secure_coding] - can't help it, it's intentional.
-        res = CPyCppyy_PyUnicode_AsWideChar(value, *(wchar_t**)address, len);
+        res = cpyrt_PyUnicode_AsWideChar(value, *(wchar_t**)address, len);
 
     if (res == -1) return false;
     return true;
 }
 
 //----------------------------------------------------------------------------
-#define CPYCPPYY_WIDESTRING_CONVERTER(name, type, encode, decode, snull)     \
-bool CPyCppyy::name##Converter::SetArg(                                      \
+#define CPYRT_WIDESTRING_CONVERTER(name, type, encode, decode, snull)     \
+bool cppjit::cpyrt::name##Converter::SetArg(                                      \
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)            \
 {                                                                            \
 /* change string encoding and copy into local buffer */                      \
@@ -1408,7 +1408,7 @@ bool CPyCppyy::name##Converter::SetArg(                                      \
     return true;                                                             \
 }                                                                            \
                                                                              \
-PyObject* CPyCppyy::name##Converter::FromMemory(void* address)               \
+PyObject* cppjit::cpyrt::name##Converter::FromMemory(void* address)               \
 {                                                                            \
 /* construct python object from C++ <type>* read at <address> */             \
     if (address && *(type**)address) {                                       \
@@ -1423,7 +1423,7 @@ PyObject* CPyCppyy::name##Converter::FromMemory(void* address)               \
     return decode((const char*)&w, 0, nullptr, nullptr);                     \
 }                                                                            \
                                                                              \
-bool CPyCppyy::name##Converter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)\
+bool cppjit::cpyrt::name##Converter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)\
 {                                                                            \
 /* convert <value> to C++ <type>*, write it at <address> */                  \
     PyObject* bstr = encode(value);                                          \
@@ -1448,11 +1448,11 @@ bool CPyCppyy::name##Converter::ToMemory(PyObject* value, void* address, PyObjec
     return true;                                                             \
 }
 
-CPYCPPYY_WIDESTRING_CONVERTER(CString16, char16_t, PyUnicode_AsUTF16String, PyUnicode_DecodeUTF16, u'\0')
-CPYCPPYY_WIDESTRING_CONVERTER(CString32, char32_t, PyUnicode_AsUTF32String, PyUnicode_DecodeUTF32, U'\0')
+CPYRT_WIDESTRING_CONVERTER(CString16, char16_t, PyUnicode_AsUTF16String, PyUnicode_DecodeUTF16, u'\0')
+CPYRT_WIDESTRING_CONVERTER(CString32, char32_t, PyUnicode_AsUTF32String, PyUnicode_DecodeUTF32, U'\0')
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::NonConstCStringConverter::SetArg(
+bool cppjit::cpyrt::NonConstCStringConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // attempt base class first (i.e. passing a string), but if that fails, try a buffer
@@ -1465,16 +1465,16 @@ bool CPyCppyy::NonConstCStringConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::NonConstCStringConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::NonConstCStringConverter::FromMemory(void* address)
 {
 // assume this is a buffer access if the size is known; otherwise assume string
     if (fMaxSize != std::string::npos)
-        return CPyCppyy_PyText_FromStringAndSize(*(char**)address, (Py_ssize_t)fMaxSize);
+        return cpyrt_PyText_FromStringAndSize(*(char**)address, (Py_ssize_t)fMaxSize);
     return this->CStringConverter::FromMemory(address);
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::VoidArrayConverter::GetAddressSpecialCase(PyObject* pyobject, void*& address)
+bool cppjit::cpyrt::VoidArrayConverter::GetAddressSpecialCase(PyObject* pyobject, void*& address)
 {
 // (1): C++11 style "null pointer"
     if (pyobject == gNullPtrObject || pyobject == gDefaultObject) {
@@ -1494,8 +1494,8 @@ bool CPyCppyy::VoidArrayConverter::GetAddressSpecialCase(PyObject* pyobject, voi
     }
 
 // (3): opaque PyCapsule (CObject in older pythons) from somewhere
-    if (CPyCppyy_PyCapsule_CheckExact(pyobject)) {
-        address = (void*)CPyCppyy_PyCapsule_GetPointer(pyobject, nullptr);
+    if (cpyrt_PyCapsule_CheckExact(pyobject)) {
+        address = (void*)cpyrt_PyCapsule_GetPointer(pyobject, nullptr);
         return true;
     }
 
@@ -1503,7 +1503,7 @@ bool CPyCppyy::VoidArrayConverter::GetAddressSpecialCase(PyObject* pyobject, voi
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::VoidArrayConverter::SetArg(
+bool cppjit::cpyrt::VoidArrayConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // just convert pointer if it is a C++ object
@@ -1530,14 +1530,14 @@ bool CPyCppyy::VoidArrayConverter::SetArg(
 // isintance instead of an exact check, b/c c_void_p is the type mapper for typedefs
 // of void* (typically opaque handles)
     if (PyObject_IsInstance(pyobject, (PyObject*)GetCTypesType(ct_c_void_p))) {
-        para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;
+        para.fValue.fVoidp = (void*)((cpyrt_tagCDataObject*)pyobject)->b_ptr;
         para.fTypeCode = 'V';
         return true;
     }
 
 // allow any other ctypes pointer type
     if (IsCTypesArrayOrPointer(pyobject)) {
-        void** payload = (void**)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;
+        void** payload = (void**)((cpyrt_tagCDataObject*)pyobject)->b_ptr;
         if (payload) {
             para.fValue.fVoidp = *payload;
             para.fTypeCode = 'p';
@@ -1559,7 +1559,7 @@ bool CPyCppyy::VoidArrayConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::VoidArrayConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::VoidArrayConverter::FromMemory(void* address)
 {
 // nothing sensible can be done, just return <address> as pylong
     if (!address || *(uintptr_t*)address == 0) {
@@ -1570,7 +1570,7 @@ PyObject* CPyCppyy::VoidArrayConverter::FromMemory(void* address)
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::VoidArrayConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::VoidArrayConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // just convert pointer if it is a C++ object
     CPPInstance* pyobj = GetCppInstance(value);
@@ -1603,11 +1603,11 @@ bool CPyCppyy::VoidArrayConverter::ToMemory(PyObject* value, void* address, PyOb
 
 #if __cplusplus >= 202002L
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class StdSpanConverter : public InstanceConverter {
 public:
-    StdSpanConverter(std::string const &typeName, Cppyy::TCppScope_t klass, bool keepControl = false)
+    StdSpanConverter(std::string const &typeName, cppjit::interop::TCppScope_t klass, bool keepControl = false)
         : InstanceConverter{klass, keepControl}, fTypeName{typeName}
     {
     }
@@ -1629,10 +1629,10 @@ class StdSpanConverter : public InstanceConverter {
     Py_buffer fBufinfo;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::StdSpanConverter::SetArg(PyObject *pyobject, Parameter &para, CallContext *ctxt)
+bool cppjit::cpyrt::StdSpanConverter::SetArg(PyObject *pyobject, Parameter &para, CallContext *ctxt)
 {
     auto typecodeFound = Utility::TypecodeMap().find(fTypeName);
 
@@ -1675,13 +1675,13 @@ bool CPyCppyy::StdSpanConverter::SetArg(PyObject *pyobject, Parameter &para, Cal
 
 
 //----------------------------------------------------------------------------
-#define CPPYY_IMPL_ARRAY_CONVERTER(name, ctype, type, code, suffix)            \
-  CPyCppyy::name##ArrayConverter::name##ArrayConverter(cdims_t dims)           \
+#define CPPJIT_IMPL_ARRAY_CONVERTER(name, ctype, type, code, suffix)            \
+  cppjit::cpyrt::name##ArrayConverter::name##ArrayConverter(cdims_t dims)           \
       : fShape(dims) {                                                         \
     fIsFixed = dims ? fShape[0] != UNKNOWN_SIZE : false;                       \
   }                                                                            \
                                                                                \
-  bool CPyCppyy::name##ArrayConverter::SetArg(                                 \
+  bool cppjit::cpyrt::name##ArrayConverter::SetArg(                                 \
       PyObject *pyobject, Parameter &para, CallContext *ctxt) {                \
     /* filter ctypes first b/c their buffer conversion will be wrong */        \
     bool convOk = false;                                                       \
@@ -1690,14 +1690,14 @@ bool CPyCppyy::StdSpanConverter::SetArg(PyObject *pyobject, Parameter &para, Cal
     if (!convOk && fShape.ndim() == 2) {                                       \
       if (Py_TYPE(pyobject) == GetCTypesPtrType(ct_##ctype)) {                 \
         para.fValue.fVoidp =                                                   \
-            (void *)((CPyCppyy_tagCDataObject *)pyobject)->b_ptr;              \
+            (void *)((cpyrt_tagCDataObject *)pyobject)->b_ptr;              \
         para.fTypeCode = 'p';                                                  \
         convOk = true;                                                         \
       } else if (Py_TYPE(pyobject) == GetCTypesType(ct_c_void_p)) {            \
         /* special case: pass address of c_void_p buffer to return the address \
          */                                                                    \
         para.fValue.fVoidp =                                                   \
-            (void *)((CPyCppyy_tagCDataObject *)pyobject)->b_ptr;              \
+            (void *)((cpyrt_tagCDataObject *)pyobject)->b_ptr;              \
         para.fTypeCode = 'p';                                                  \
         convOk = true;                                                         \
       } else if (LowLevelView_Check(pyobject) &&                               \
@@ -1714,19 +1714,19 @@ bool CPyCppyy::StdSpanConverter::SetArg(PyObject *pyobject, Parameter &para, Cal
       PyTypeObject *ctypes_type = GetCTypesType(ct_##ctype);                   \
       if (Py_TYPE(pyobject) == ctypes_type) {                                  \
         para.fValue.fVoidp =                                                   \
-            (void *)((CPyCppyy_tagCDataObject *)pyobject)->b_ptr;              \
+            (void *)((cpyrt_tagCDataObject *)pyobject)->b_ptr;              \
         para.fTypeCode = 'p';                                                  \
         convOk = true;                                                         \
       } else if (Py_TYPE(pyobject) == GetCTypesPtrType(ct_##ctype)) {          \
         para.fValue.fVoidp =                                                   \
-            (void *)((CPyCppyy_tagCDataObject *)pyobject)->b_ptr;              \
+            (void *)((cpyrt_tagCDataObject *)pyobject)->b_ptr;              \
         para.fTypeCode = 'V';                                                  \
         convOk = true;                                                         \
       } else if (IsPyCArgObject(pyobject)) {                                   \
-        CPyCppyy_tagPyCArgObject *carg = (CPyCppyy_tagPyCArgObject *)pyobject; \
+        cpyrt_tagPyCArgObject *carg = (cpyrt_tagPyCArgObject *)pyobject; \
         if (carg->obj && Py_TYPE(carg->obj) == ctypes_type) {                  \
           para.fValue.fVoidp =                                                 \
-              (void *)((CPyCppyy_tagCDataObject *)carg->obj)->b_ptr;           \
+              (void *)((cpyrt_tagCDataObject *)carg->obj)->b_ptr;           \
           para.fTypeCode = 'p';                                                \
           convOk = true;                                                       \
         }                                                                      \
@@ -1752,13 +1752,13 @@ bool CPyCppyy::StdSpanConverter::SetArg(PyObject *pyobject, Parameter &para, Cal
     return convOk;                                                             \
   }                                                                            \
                                                                                \
-  PyObject *CPyCppyy::name##ArrayConverter::FromMemory(void *address) {        \
+  PyObject *cppjit::cpyrt::name##ArrayConverter::FromMemory(void *address) {        \
     if (!fIsFixed)                                                             \
       return CreateLowLevelView##suffix((type **)address, fShape);             \
     return CreateLowLevelView##suffix(*(type **)address, fShape);              \
   }                                                                            \
                                                                                \
-  bool CPyCppyy::name##ArrayConverter::ToMemory(                               \
+  bool cppjit::cpyrt::name##ArrayConverter::ToMemory(                               \
       PyObject *value, void *address, PyObject *ctxt) {                        \
     if (fShape.ndim() <= 1 || fIsFixed) {                                      \
       void *buf = nullptr;                                                     \
@@ -1802,40 +1802,40 @@ bool CPyCppyy::StdSpanConverter::SetArg(PyObject *pyobject, Parameter &para, Cal
   }
 
 //----------------------------------------------------------------------------
-CPPYY_IMPL_ARRAY_CONVERTER(Bool,     c_bool,       bool,                 '?', )
-CPPYY_IMPL_ARRAY_CONVERTER(SChar,    c_char,       signed char,          'b', )
-CPPYY_IMPL_ARRAY_CONVERTER(UChar,    c_ubyte,      unsigned char,        'B', )
-CPPYY_IMPL_ARRAY_CONVERTER(Byte,     c_ubyte,      std::byte,            'B', )
-CPPYY_IMPL_ARRAY_CONVERTER(Int8,     c_byte,       int8_t,               'b', _i8)
-CPPYY_IMPL_ARRAY_CONVERTER(UInt8,    c_ubyte,      uint8_t,              'B', _i8)
-CPPYY_IMPL_ARRAY_CONVERTER(Short,    c_short,      short,                'h', )
-CPPYY_IMPL_ARRAY_CONVERTER(UShort,   c_ushort,     unsigned short,       'H', )
-CPPYY_IMPL_ARRAY_CONVERTER(Int,      c_int,        int,                  'i', )
-CPPYY_IMPL_ARRAY_CONVERTER(UInt,     c_uint,       unsigned int,         'I', )
-CPPYY_IMPL_ARRAY_CONVERTER(Long,     c_long,       long,                 'l', )
-CPPYY_IMPL_ARRAY_CONVERTER(ULong,    c_ulong,      unsigned long,        'L', )
-CPPYY_IMPL_ARRAY_CONVERTER(LLong,    c_longlong,   long long,            'q', )
-CPPYY_IMPL_ARRAY_CONVERTER(ULLong,   c_ulonglong,  unsigned long long,   'Q', )
-CPPYY_IMPL_ARRAY_CONVERTER(Float,    c_float,      float,                'f', )
-CPPYY_IMPL_ARRAY_CONVERTER(Double,   c_double,     double,               'd', )
-CPPYY_IMPL_ARRAY_CONVERTER(LDouble,  c_longdouble, long double,          'g', )
-CPPYY_IMPL_ARRAY_CONVERTER(ComplexF, c_fcomplex,   std::complex<float>,  'z', )
-CPPYY_IMPL_ARRAY_CONVERTER(ComplexD, c_complex,    std::complex<double>, 'Z', )
-
-
-//----------------------------------------------------------------------------
-bool CPyCppyy::CStringArrayConverter::SetArg(
+CPPJIT_IMPL_ARRAY_CONVERTER(Bool,     c_bool,       bool,                 '?', )
+CPPJIT_IMPL_ARRAY_CONVERTER(SChar,    c_char,       signed char,          'b', )
+CPPJIT_IMPL_ARRAY_CONVERTER(UChar,    c_ubyte,      unsigned char,        'B', )
+CPPJIT_IMPL_ARRAY_CONVERTER(Byte,     c_ubyte,      std::byte,            'B', )
+CPPJIT_IMPL_ARRAY_CONVERTER(Int8,     c_byte,       int8_t,               'b', _i8)
+CPPJIT_IMPL_ARRAY_CONVERTER(UInt8,    c_ubyte,      uint8_t,              'B', _i8)
+CPPJIT_IMPL_ARRAY_CONVERTER(Short,    c_short,      short,                'h', )
+CPPJIT_IMPL_ARRAY_CONVERTER(UShort,   c_ushort,     unsigned short,       'H', )
+CPPJIT_IMPL_ARRAY_CONVERTER(Int,      c_int,        int,                  'i', )
+CPPJIT_IMPL_ARRAY_CONVERTER(UInt,     c_uint,       unsigned int,         'I', )
+CPPJIT_IMPL_ARRAY_CONVERTER(Long,     c_long,       long,                 'l', )
+CPPJIT_IMPL_ARRAY_CONVERTER(ULong,    c_ulong,      unsigned long,        'L', )
+CPPJIT_IMPL_ARRAY_CONVERTER(LLong,    c_longlong,   long long,            'q', )
+CPPJIT_IMPL_ARRAY_CONVERTER(ULLong,   c_ulonglong,  unsigned long long,   'Q', )
+CPPJIT_IMPL_ARRAY_CONVERTER(Float,    c_float,      float,                'f', )
+CPPJIT_IMPL_ARRAY_CONVERTER(Double,   c_double,     double,               'd', )
+CPPJIT_IMPL_ARRAY_CONVERTER(LDouble,  c_longdouble, long double,          'g', )
+CPPJIT_IMPL_ARRAY_CONVERTER(ComplexF, c_fcomplex,   std::complex<float>,  'z', )
+CPPJIT_IMPL_ARRAY_CONVERTER(ComplexD, c_complex,    std::complex<double>, 'Z', )
+
+
+//----------------------------------------------------------------------------
+bool cppjit::cpyrt::CStringArrayConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
     if (Py_TYPE(pyobject) == GetCTypesPtrType(ct_c_char_p) || \
             (1 < fShape.ndim() && PyObject_IsInstance(pyobject, (PyObject*)GetCTypesType(ct_c_pointer)))) {
     // 2nd predicate is ebatable: it's a catch-all for ctypes-styled multi-dimensional objects,
     // which at this point does not check further dimensionality
-        para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;
+        para.fValue.fVoidp = (void*)((cpyrt_tagCDataObject*)pyobject)->b_ptr;
         para.fTypeCode = 'V';
         return true;
 
-    } else if (PySequence_Check(pyobject) && !CPyCppyy_PyText_Check(pyobject)
+    } else if (PySequence_Check(pyobject) && !cpyrt_PyText_Check(pyobject)
         && !PyBytes_Check(pyobject)
     ) {
         //for (auto& p : fBuffer) free(p);
@@ -1852,7 +1852,7 @@ bool CPyCppyy::CStringArrayConverter::SetArg(
             PyObject* item = PySequence_GetItem(pyobject, i);
             if (item) {
                 Py_ssize_t sz;
-                const char* p = CPyCppyy_PyText_AsStringAndSize(item, &sz);
+                const char* p = cpyrt_PyText_AsStringAndSize(item, &sz);
                 Py_DECREF(item);
 
                 if (p) fBuffer.push_back(p);
@@ -1875,7 +1875,7 @@ bool CPyCppyy::CStringArrayConverter::SetArg(
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CStringArrayConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::CStringArrayConverter::FromMemory(void* address)
 {
     if (fIsFixed)
         return CreateLowLevelView(*(char**)address, fShape);
@@ -1885,7 +1885,7 @@ PyObject* CPyCppyy::CStringArrayConverter::FromMemory(void* address)
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::NonConstCStringArrayConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::NonConstCStringArrayConverter::FromMemory(void* address)
 {
     if (fIsFixed)
         return CreateLowLevelView(*(char**)address, fShape);
@@ -1895,7 +1895,7 @@ PyObject* CPyCppyy::NonConstCStringArrayConverter::FromMemory(void* address)
 }
 
 //- converters for special cases ---------------------------------------------
-bool CPyCppyy::NullptrConverter::SetArg(PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
+bool cppjit::cpyrt::NullptrConverter::SetArg(PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // Only allow C++11 style nullptr to pass
     if (pyobject == gNullPtrObject || pyobject == gDefaultObject) {
@@ -1909,7 +1909,7 @@ bool CPyCppyy::NullptrConverter::SetArg(PyObject* pyobject, Parameter& para, Cal
 
 //----------------------------------------------------------------------------
 template<typename T>
-static inline bool CPyCppyy_PyUnicodeAsBytes2Buffer(PyObject* pyobject, T& buffer) {
+static inline bool cpyrt_PyUnicodeAsBytes2Buffer(PyObject* pyobject, T& buffer) {
     PyObject* pybytes = nullptr;
     if (PyBytes_Check(pyobject)) {
         Py_INCREF(pyobject);
@@ -1930,14 +1930,14 @@ static inline bool CPyCppyy_PyUnicodeAsBytes2Buffer(PyObject* pyobject, T& buffe
     return false;
 }
 
-#define CPPYY_IMPL_STRING_AS_PRIMITIVE_CONVERTER(name, type, F1, F2)         \
-CPyCppyy::name##Converter::name##Converter(bool keepControl) :               \
-    InstanceConverter(Cppyy::GetFullScope(#type), keepControl) {}            \
+#define CPPJIT_IMPL_STRING_AS_PRIMITIVE_CONVERTER(name, type, F1, F2)         \
+cppjit::cpyrt::name##Converter::name##Converter(bool keepControl) :               \
+    InstanceConverter(cppjit::interop::GetFullScope(#type), keepControl) {}            \
                                                                              \
-bool CPyCppyy::name##Converter::SetArg(                                      \
+bool cppjit::cpyrt::name##Converter::SetArg(                                      \
     PyObject* pyobject, Parameter& para, CallContext* ctxt)                  \
 {                                                                            \
-    if (CPyCppyy_PyUnicodeAsBytes2Buffer(pyobject, fBuffer)) {               \
+    if (cpyrt_PyUnicodeAsBytes2Buffer(pyobject, fBuffer)) {               \
         para.fValue.fVoidp = &fBuffer;                                       \
         para.fTypeCode = 'V';                                                \
         return true;                                                         \
@@ -1953,35 +1953,35 @@ bool CPyCppyy::name##Converter::SetArg(                                      \
     return false;                                                            \
 }                                                                            \
                                                                              \
-PyObject* CPyCppyy::name##Converter::FromMemory(void* address)               \
+PyObject* cppjit::cpyrt::name##Converter::FromMemory(void* address)               \
 {                                                                            \
     if (address)                                                             \
         return InstanceConverter::FromMemory(address);                       \
     auto* empty = new type();                                                \
-    return BindCppObjectNoCast(Cppyy::TCppObject_t((void*)empty), fClass, CPPInstance::kIsOwner);\
+    return BindCppObjectNoCast(cppjit::interop::TCppObject_t((void*)empty), fClass, CPPInstance::kIsOwner);\
 }                                                                            \
                                                                              \
-bool CPyCppyy::name##Converter::ToMemory(                                    \
+bool cppjit::cpyrt::name##Converter::ToMemory(                                    \
     PyObject* value, void* address, PyObject* ctxt)                          \
 {                                                                            \
-    if (CPyCppyy_PyUnicodeAsBytes2Buffer(value, *((type*)address)))          \
+    if (cpyrt_PyUnicodeAsBytes2Buffer(value, *((type*)address)))          \
         return true;                                                         \
     return InstanceConverter::ToMemory(value, address, ctxt);                \
 }
 
-CPPYY_IMPL_STRING_AS_PRIMITIVE_CONVERTER(STLString, std::string, c_str, size)
+CPPJIT_IMPL_STRING_AS_PRIMITIVE_CONVERTER(STLString, std::string, c_str, size)
 
 
-CPyCppyy::STLWStringConverter::STLWStringConverter(bool keepControl) :
-    InstanceConverter(Cppyy::GetFullScope("std::wstring"), keepControl) {}
+cppjit::cpyrt::STLWStringConverter::STLWStringConverter(bool keepControl) :
+    InstanceConverter(cppjit::interop::GetFullScope("std::wstring"), keepControl) {}
 
-bool CPyCppyy::STLWStringConverter::SetArg(
+bool cppjit::cpyrt::STLWStringConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
     if (PyUnicode_Check(pyobject)) {
-        Py_ssize_t len = CPyCppyy_PyUnicode_GET_SIZE(pyobject);
+        Py_ssize_t len = cpyrt_PyUnicode_GET_SIZE(pyobject);
         fBuffer.resize(len);
-        CPyCppyy_PyUnicode_AsWideChar(pyobject, &fBuffer[0], len);
+        cpyrt_PyUnicode_AsWideChar(pyobject, &fBuffer[0], len);
         para.fValue.fVoidp = &fBuffer;
         para.fTypeCode = 'V';
         return true;
@@ -1996,7 +1996,7 @@ bool CPyCppyy::STLWStringConverter::SetArg(
     return false;
 }
 
-PyObject* CPyCppyy::STLWStringConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::STLWStringConverter::FromMemory(void* address)
 {
     if (address)
         return PyUnicode_FromWideChar(((std::wstring*)address)->c_str(), ((std::wstring*)address)->size());
@@ -2004,12 +2004,12 @@ PyObject* CPyCppyy::STLWStringConverter::FromMemory(void* address)
     return PyUnicode_FromWideChar(&w, 0);
 }
 
-bool CPyCppyy::STLWStringConverter::ToMemory(PyObject* value, void* address, PyObject* ctxt)
+bool cppjit::cpyrt::STLWStringConverter::ToMemory(PyObject* value, void* address, PyObject* ctxt)
 {
     if (PyUnicode_Check(value)) {
-        Py_ssize_t len = CPyCppyy_PyUnicode_GET_SIZE(value);
+        Py_ssize_t len = cpyrt_PyUnicode_GET_SIZE(value);
         wchar_t* buf = new wchar_t[len+1];
-        CPyCppyy_PyUnicode_AsWideChar(value, buf, len);
+        cpyrt_PyUnicode_AsWideChar(value, buf, len);
         *((std::wstring*)address) = std::wstring(buf, len);
         delete[] buf;
         return true;
@@ -2017,10 +2017,10 @@ bool CPyCppyy::STLWStringConverter::ToMemory(PyObject* value, void* address, PyO
     return InstanceConverter::ToMemory(value, address, ctxt);
 }
 
-CPyCppyy::STLStringViewConverter::STLStringViewConverter(bool keepControl) :
-    InstanceConverter(Cppyy::GetFullScope("std::string_view"), keepControl) {}
+cppjit::cpyrt::STLStringViewConverter::STLStringViewConverter(bool keepControl) :
+    InstanceConverter(cppjit::interop::GetFullScope("std::string_view"), keepControl) {}
 
-bool CPyCppyy::STLStringViewConverter::SetArg(
+bool cppjit::cpyrt::STLStringViewConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // normal instance convertion (eg. string_view object passed)
@@ -2035,7 +2035,7 @@ bool CPyCppyy::STLStringViewConverter::SetArg(
 
 // passing of a Python string; buffering done Python-side b/c str is immutable
     Py_ssize_t len;
-    const char* cstr = CPyCppyy_PyText_AsStringAndSize(pyobject, &len);
+    const char* cstr = cpyrt_PyText_AsStringAndSize(pyobject, &len);
     if (cstr) {
         SetLifeLine(ctxt->fPyContext, pyobject, (intptr_t)this);
         fBuffer = std::string_view(cstr, (std::string_view::size_type)len);
@@ -2050,7 +2050,7 @@ bool CPyCppyy::STLStringViewConverter::SetArg(
 // special case of a C++ std::string object; life-time management is left to
 // the caller to ensure any external changes propagate correctly
     if (CPPInstance_Check(pyobject)) {
-        static Cppyy::TCppScope_t sStringID = Cppyy::GetUnderlyingScope(Cppyy::GetFullScope("std::string"));
+        static cppjit::interop::TCppScope_t sStringID = cppjit::interop::GetUnderlyingScope(cppjit::interop::GetFullScope("std::string"));
         CPPInstance* pyobj = (CPPInstance*)pyobject;
         if (pyobj->ObjectIsA() == sStringID) {
             void* ptr = pyobj->GetObject();
@@ -2069,7 +2069,7 @@ bool CPyCppyy::STLStringViewConverter::SetArg(
     return false;
 }
 
-PyObject* CPyCppyy::STLStringViewConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::STLStringViewConverter::FromMemory(void* address)
 {
     if (address)
         return InstanceConverter::FromMemory(address);
@@ -2077,7 +2077,7 @@ PyObject* CPyCppyy::STLStringViewConverter::FromMemory(void* address)
     return BindCppObjectNoCast(empty, fClass, CPPInstance::kIsOwner);
 }
 
-bool CPyCppyy::STLStringViewConverter::ToMemory(
+bool cppjit::cpyrt::STLStringViewConverter::ToMemory(
     PyObject* value, void* address, PyObject* ctxt)
 {
 // common case of simple object assignment
@@ -2086,7 +2086,7 @@ bool CPyCppyy::STLStringViewConverter::ToMemory(
 
 // assignment of a Python string; buffering done Python-side b/c str is immutable
     Py_ssize_t len;
-    const char* cstr = CPyCppyy_PyText_AsStringAndSize(value, &len);
+    const char* cstr = cpyrt_PyText_AsStringAndSize(value, &len);
     if (cstr) {
         SetLifeLine(ctxt, value, (intptr_t)this);
         *reinterpret_cast<std::string_view*>(address) = \
@@ -2098,7 +2098,7 @@ bool CPyCppyy::STLStringViewConverter::ToMemory(
 }
 
 
-bool CPyCppyy::STLStringMoveConverter::SetArg(
+bool cppjit::cpyrt::STLStringMoveConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ std::string&&, set arg for call
@@ -2128,28 +2128,28 @@ bool CPyCppyy::STLStringMoveConverter::SetArg(
 
 //----------------------------------------------------------------------------
 template <bool ISCONST>
-bool CPyCppyy::InstancePtrConverter<ISCONST>::SetArg(
+bool cppjit::cpyrt::InstancePtrConverter<ISCONST>::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ instance*, set arg for call
-    CPPInstance* pyobj = GetCppInstance(pyobject, ISCONST ? fClass : Cppyy::TCppScope_t{});
+    CPPInstance* pyobj = GetCppInstance(pyobject, ISCONST ? fClass : cppjit::interop::TCppScope_t{});
     if (!pyobj) {
         if (GetAddressSpecialCase(pyobject, para.fValue.fVoidp)) {
             para.fTypeCode = 'p';      // allow special cases such as nullptr
             return true;
         }
 
-   // not a cppyy object (TODO: handle SWIG etc.)
+   // not a cppjit object (TODO: handle SWIG etc.)
         return false;
     }
 
     // smart pointers should only extract the pointer if this is NOT an implicit
     // conversion to another smart pointer
-    if (pyobj->IsSmart() && IsConstructor(ctxt->fFlags) && Cppyy::IsSmartPtr(ctxt->fCurScope))
+    if (pyobj->IsSmart() && IsConstructor(ctxt->fFlags) && cppjit::interop::IsSmartPtr(ctxt->fCurScope))
         return false;
 
-    Cppyy::TCppScope_t oisa = pyobj->ObjectIsA();
-    if (oisa && (oisa == fClass || Cppyy::IsSubclass(oisa, fClass))) {
+    cppjit::interop::TCppScope_t oisa = pyobj->ObjectIsA();
+    if (oisa && (oisa == fClass || cppjit::interop::IsSubclass(oisa, fClass))) {
     // depending on memory policy, some objects need releasing when passed into functions
         if (!KeepControl() && !UseStrictOwnership(ctxt))
             pyobj->CppOwns();
@@ -2157,7 +2157,7 @@ bool CPyCppyy::InstancePtrConverter<ISCONST>::SetArg(
     // calculate offset between formal and actual arguments
         para.fValue.fVoidp = pyobj->GetObject();
         if (oisa != fClass) {
-            para.fValue.fIntPtr += Cppyy::GetBaseOffset(
+            para.fValue.fIntPtr += cppjit::interop::GetBaseOffset(
                 oisa, fClass, para.fValue.fVoidp, 1 /* up-cast */);
         }
 
@@ -2171,7 +2171,7 @@ bool CPyCppyy::InstancePtrConverter<ISCONST>::SetArg(
 
 //----------------------------------------------------------------------------
 template <bool ISCONST>
-PyObject* CPyCppyy::InstancePtrConverter<ISCONST>::FromMemory(void* address)
+PyObject* cppjit::cpyrt::InstancePtrConverter<ISCONST>::FromMemory(void* address)
 {
 // construct python object from C++ instance read at <address>
     if (ISCONST)
@@ -2181,10 +2181,10 @@ PyObject* CPyCppyy::InstancePtrConverter<ISCONST>::FromMemory(void* address)
 
 //----------------------------------------------------------------------------
 template <bool ISCONST>
-bool CPyCppyy::InstancePtrConverter<ISCONST>::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::InstancePtrConverter<ISCONST>::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // convert <value> to C++ instance, write it at <address>
-    CPPInstance* pyobj = GetCppInstance(value, ISCONST ? fClass : Cppyy::TCppScope_t{});
+    CPPInstance* pyobj = GetCppInstance(value, ISCONST ? fClass : cppjit::interop::TCppScope_t{});
     if (!pyobj) {
         void* ptr = nullptr;
         if (GetAddressSpecialCase(value, ptr)) {
@@ -2192,11 +2192,11 @@ bool CPyCppyy::InstancePtrConverter<ISCONST>::ToMemory(PyObject* value, void* ad
             return true;
         }
 
-    // not a cppyy object (TODO: handle SWIG etc.)
+    // not a cppjit object (TODO: handle SWIG etc.)
         return false;
     }
 
-    if (Cppyy::IsSubclass(pyobj->ObjectIsA(), fClass)) {
+    if (cppjit::interop::IsSubclass(pyobj->ObjectIsA(), fClass)) {
     // depending on memory policy, some objects need releasing when passed into functions
         if (!KeepControl() && CallContext::sMemoryPolicy != CallContext::kUseStrict)
             ((CPPInstance*)value)->CppOwns();
@@ -2211,24 +2211,24 @@ bool CPyCppyy::InstancePtrConverter<ISCONST>::ToMemory(PyObject* value, void* ad
 // TODO: CONSOLIDATE Instance, InstanceRef, InstancePtr ...
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::InstanceConverter::SetArg(
+bool cppjit::cpyrt::InstanceConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ instance, set arg for call
     CPPInstance* pyobj = GetCppInstance(pyobject, fClass);
     if (pyobj) {
         auto oisa = pyobj->ObjectIsA();
-        if (oisa && ((oisa == (Cppyy::IsTypedefed(fClass)
-                                   ? Cppyy::GetUnderlyingScope(fClass)
+        if (oisa && ((oisa == (cppjit::interop::IsTypedefed(fClass)
+                                   ? cppjit::interop::GetUnderlyingScope(fClass)
                                    : fClass)) ||
-                     Cppyy::IsSubclass(oisa, fClass))) {
+                     cppjit::interop::IsSubclass(oisa, fClass))) {
         // calculate offset between formal and actual arguments
             para.fValue.fVoidp = pyobj->GetObject();
             if (!para.fValue.fVoidp)
                 return false;
 
             if (oisa != fClass) {
-                para.fValue.fIntPtr += Cppyy::GetBaseOffset(
+                para.fValue.fIntPtr += cppjit::interop::GetBaseOffset(
                     pyobj->ObjectIsA(), fClass, para.fValue.fVoidp, 1 /* up-cast */);
             }
 
@@ -2241,17 +2241,17 @@ bool CPyCppyy::InstanceConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::InstanceConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::InstanceConverter::FromMemory(void* address)
 {
 // This should not need a cast (ie. BindCppObjectNoCast), but performing the cast
 // here means callbacks receive down-casted object when passed by-ptr, which is
 // needed for object identity. The latter case is assumed to be more common than
 // conversion of (global) objects.
-    return BindCppObject((Cppyy::TCppObject_t)address, fClass);
+    return BindCppObject((cppjit::interop::TCppObject_t)address, fClass);
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::InstanceConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::InstanceConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // assign value to C++ instance living at <address> through assignment operator
     PyObject* pyobj = BindCppObjectNoCast(address, fClass);
@@ -2267,11 +2267,11 @@ bool CPyCppyy::InstanceConverter::ToMemory(PyObject* value, void* address, PyObj
 
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::InstanceRefConverter::SetArg(
+bool cppjit::cpyrt::InstanceRefConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ instance&, set arg for call
-    CPPInstance* pyobj = GetCppInstance(pyobject, fIsConst ? fClass : Cppyy::TCppScope_t{});
+    CPPInstance* pyobj = GetCppInstance(pyobject, fIsConst ? fClass : cppjit::interop::TCppScope_t{});
     if (pyobj) {
 
     // reject moves
@@ -2281,10 +2281,10 @@ bool CPyCppyy::InstanceRefConverter::SetArg(
     // smart pointers can end up here in case of a move, so preferentially match
     // the smart type directly
         bool argset = false;
-        Cppyy::TCppScope_t cls;
+        cppjit::interop::TCppScope_t cls;
         if (pyobj->IsSmart()) {
             cls = pyobj->ObjectIsA(false);
-            if (cls && Cppyy::IsSubclass(cls, fClass)) {
+            if (cls && cppjit::interop::IsSubclass(cls, fClass)) {
                 para.fValue.fVoidp = pyobj->GetObjectRaw();
                 argset = true;
             }
@@ -2292,7 +2292,7 @@ bool CPyCppyy::InstanceRefConverter::SetArg(
 
         if (!argset) {
             cls = pyobj->ObjectIsA();
-            if (cls && Cppyy::IsSubclass(cls, fClass)) {
+            if (cls && cppjit::interop::IsSubclass(cls, fClass)) {
                 para.fValue.fVoidp = pyobj->GetObject();
                 argset = true;
             }
@@ -2307,7 +2307,7 @@ bool CPyCppyy::InstanceRefConverter::SetArg(
 
         // calculate offset between formal and actual arguments
             if (cls != fClass) {
-                para.fValue.fIntPtr += Cppyy::GetBaseOffset(
+                para.fValue.fIntPtr += cppjit::interop::GetBaseOffset(
                     cls, fClass, para.fValue.fVoidp, 1 /* up-cast */);
             }
 
@@ -2323,13 +2323,13 @@ bool CPyCppyy::InstanceRefConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::InstanceRefConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::InstanceRefConverter::FromMemory(void* address)
 {
-    return BindCppObjectNoCast((Cppyy::TCppObject_t)address, fClass, CPPInstance::kIsReference);
+    return BindCppObjectNoCast((cppjit::interop::TCppObject_t)address, fClass, CPPInstance::kIsReference);
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::InstanceMoveConverter::SetArg(
+bool cppjit::cpyrt::InstanceMoveConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ instance&&, set arg for call
@@ -2361,7 +2361,7 @@ bool CPyCppyy::InstanceMoveConverter::SetArg(
 
 //----------------------------------------------------------------------------
 template <bool ISREFERENCE>
-bool CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::SetArg(
+bool cppjit::cpyrt::InstancePtrPtrConverter<ISREFERENCE>::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // convert <pyobject> to C++ instance**, set arg for call
@@ -2373,10 +2373,10 @@ bool CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::SetArg(
             para.fTypeCode = 'p';
             return true;
         }
-        return false;              // not a cppyy object (TODO: handle SWIG etc.)
+        return false;              // not a cppjit object (TODO: handle SWIG etc.)
     }
 
-    if (Cppyy::IsSubclass(pyobj->ObjectIsA(), fClass)) {
+    if (cppjit::interop::IsSubclass(pyobj->ObjectIsA(), fClass)) {
     // depending on memory policy, some objects need releasing when passed into functions
         if (!KeepControl() && !UseStrictOwnership(ctxt))
             pyobj->CppOwns();
@@ -2395,7 +2395,7 @@ bool CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::SetArg(
 
 //----------------------------------------------------------------------------
 template <bool ISREFERENCE>
-PyObject* CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::FromMemory(void* address)
+PyObject* cppjit::cpyrt::InstancePtrPtrConverter<ISREFERENCE>::FromMemory(void* address)
 {
 // construct python object from C++ instance* read at <address>
     return BindCppObject(*(void**)address, fClass, CPPInstance::kIsReference | CPPInstance::kIsPtrPtr);
@@ -2403,7 +2403,7 @@ PyObject* CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::FromMemory(void* addre
 
 //----------------------------------------------------------------------------
 template <bool ISREFERENCE>
-bool CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::ToMemory(
+bool cppjit::cpyrt::InstancePtrPtrConverter<ISREFERENCE>::ToMemory(
     PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // convert <value> to C++ instance*, write it at <address>
@@ -2414,10 +2414,10 @@ bool CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::ToMemory(
             *(void**)address = nullptr;
             return true;
         }
-        return false;              // not a cppyy object (TODO: handle SWIG etc.)
+        return false;              // not a cppjit object (TODO: handle SWIG etc.)
     }
 
-    if (Cppyy::IsSubclass(pyobj->ObjectIsA(), fClass)) {
+    if (cppjit::interop::IsSubclass(pyobj->ObjectIsA(), fClass)) {
     // depending on memory policy, some objects need releasing when passed into functions
         if (!KeepControl() && CallContext::sMemoryPolicy != CallContext::kUseStrict)
             pyobj->CppOwns();
@@ -2434,16 +2434,16 @@ bool CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::ToMemory(
 }
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 // Instantiate the templates
-    template class CPyCppyy::InstancePtrConverter<true>;
-    template class CPyCppyy::InstancePtrConverter<false>;
-    template class CPyCppyy::InstancePtrPtrConverter<true>;
-    template class CPyCppyy::InstancePtrPtrConverter<false>;
+    template class cppjit::cpyrt::InstancePtrConverter<true>;
+    template class cppjit::cpyrt::InstancePtrConverter<false>;
+    template class cppjit::cpyrt::InstancePtrPtrConverter<true>;
+    template class cppjit::cpyrt::InstancePtrPtrConverter<false>;
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::InstanceArrayConverter::SetArg(
+bool cppjit::cpyrt::InstanceArrayConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* txt */)
 {
 // convert <pyobject> to C++ instance**, set arg for call
@@ -2465,7 +2465,7 @@ bool CPyCppyy::InstanceArrayConverter::SetArg(
     if (!CPPInstance_Check(first))
         return false;              // should not happen
 
-    if (Cppyy::IsSubclass(((CPPInstance*)first)->ObjectIsA(), fClass)) {
+    if (cppjit::interop::IsSubclass(((CPPInstance*)first)->ObjectIsA(), fClass)) {
     // no memory policies supported; set pointer (may be null) and declare success
         para.fValue.fVoidp = ((CPPInstance*)first)->GetObject();
         para.fTypeCode = 'p';
@@ -2476,14 +2476,14 @@ bool CPyCppyy::InstanceArrayConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::InstanceArrayConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::InstanceArrayConverter::FromMemory(void* address)
 {
 // construct python tuple of instances from C++ array read at <address>
     return BindCppObjectArray(*(char**)address, fClass, fShape);
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::InstanceArrayConverter::ToMemory(
+bool cppjit::cpyrt::InstanceArrayConverter::ToMemory(
     PyObject* /* value */, void* /* address */, PyObject* /* ctxt */)
 {
 // convert <value> to C++ array of instances, write it at <address>
@@ -2497,7 +2497,7 @@ bool CPyCppyy::InstanceArrayConverter::ToMemory(
 //___________________________________________________________________________
 // Cling WORKAROUND -- classes for STL iterators are completely undefined in that
 // they come in a bazillion different guises, so just do whatever
-bool CPyCppyy::STLIteratorConverter::SetArg(
+bool cppjit::cpyrt::STLIteratorConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
     if (!CPPInstance_Check(pyobject))
@@ -2512,7 +2512,7 @@ bool CPyCppyy::STLIteratorConverter::SetArg(
 // -- END Cling WORKAROUND
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::VoidPtrRefConverter::SetArg(
+bool cppjit::cpyrt::VoidPtrRefConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // convert <pyobject> to C++ void*&, set arg for call
@@ -2527,13 +2527,13 @@ bool CPyCppyy::VoidPtrRefConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::VoidPtrPtrConverter::VoidPtrPtrConverter(cdims_t dims, const std::string &failureMsg) :
+cppjit::cpyrt::VoidPtrPtrConverter::VoidPtrPtrConverter(cdims_t dims, const std::string &failureMsg) :
         fShape(dims), fFailureMsg (failureMsg) {
     fIsFixed = dims ? fShape[0] != UNKNOWN_SIZE : false;
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::VoidPtrPtrConverter::SetArg(
+bool cppjit::cpyrt::VoidPtrPtrConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // convert <pyobject> to C++ void**, set arg for call
@@ -2544,9 +2544,9 @@ bool CPyCppyy::VoidPtrPtrConverter::SetArg(
         para.fTypeCode = 'p';
         return true;
     } else if (IsPyCArgObject(pyobject)) {
-        CPyCppyy_tagPyCArgObject* carg = (CPyCppyy_tagPyCArgObject*)pyobject;
+        cpyrt_tagPyCArgObject* carg = (cpyrt_tagPyCArgObject*)pyobject;
         if (carg->obj) {
-            para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)carg->obj)->b_ptr;
+            para.fValue.fVoidp = (void*)((cpyrt_tagCDataObject*)carg->obj)->b_ptr;
             para.fTypeCode = 'p';
             return true;
         }
@@ -2566,7 +2566,7 @@ bool CPyCppyy::VoidPtrPtrConverter::SetArg(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::VoidPtrPtrConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::VoidPtrPtrConverter::FromMemory(void* address)
 {
 // read a void** from address; since this is unknown, uintptr_t is used (user can cast)
     if (!address || *(ptrdiff_t*)address == 0) {
@@ -2579,7 +2579,7 @@ PyObject* CPyCppyy::VoidPtrPtrConverter::FromMemory(void* address)
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::PyObjectConverter::SetArg(
+bool cppjit::cpyrt::PyObjectConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* /* ctxt */)
 {
 // by definition: set and declare success
@@ -2588,7 +2588,7 @@ bool CPyCppyy::PyObjectConverter::SetArg(
     return true;
 }
 
-PyObject* CPyCppyy::PyObjectConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::PyObjectConverter::FromMemory(void* address)
 {
 // construct python object from C++ PyObject* read at <address>
     PyObject* pyobject = *((PyObject**)address);
@@ -2601,7 +2601,7 @@ PyObject* CPyCppyy::PyObjectConverter::FromMemory(void* address)
     return pyobject;
 }
 
-bool CPyCppyy::PyObjectConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
+bool cppjit::cpyrt::PyObjectConverter::ToMemory(PyObject* value, void* address, PyObject* /* ctxt */)
 {
 // no conversion needed, write <value> at <address>
     Py_INCREF(value);
@@ -2660,7 +2660,7 @@ static void* PyFunction_AsCPointer(PyObject* pyobject,
     if (true_signature.rfind("(void)") != std::string::npos)
         true_signature = true_signature.substr(0, true_signature.size() - 6) + "()";
 
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
 
     if (CPPOverload_Check(pyobject)) {
         CPPOverload* ol = (CPPOverload*)pyobject;
@@ -2670,7 +2670,7 @@ static void* PyFunction_AsCPointer(PyObject* pyobject,
     // find the overload with matching signature
         for (auto& m : ol->fMethodInfo->fMethods) {
             PyObject* sig = m->GetSignature(false);
-            bool found = true_signature == CPyCppyy_PyText_AsString(sig);
+            bool found = true_signature == cpyrt_PyText_AsString(sig);
             Py_DECREF(sig);
             if (found) {
                 void* fptr = (void*)m->GetFunctionAddress();
@@ -2688,11 +2688,11 @@ static void* PyFunction_AsCPointer(PyObject* pyobject,
         TemplateProxy* pytmpl = (TemplateProxy*)pyobject;
         std::string fullname = pytmpl->fTI->fCppName;
         if (pytmpl->fTemplateArgs)
-            fullname += CPyCppyy_PyText_AsString(pytmpl->fTemplateArgs);
-        Cppyy::TCppScope_t scope = ((CPPClass*)pytmpl->fTI->fPyClass)->fCppType;
-        Cppyy::TCppMethod_t cppmeth = Cppyy::GetMethodTemplate(scope, fullname, true_signature);
+            fullname += cpyrt_PyText_AsString(pytmpl->fTemplateArgs);
+        cppjit::interop::TCppScope_t scope = ((CPPClass*)pytmpl->fTI->fPyClass)->fCppType;
+        cppjit::interop::TCppMethod_t cppmeth = cppjit::interop::GetMethodTemplate(scope, fullname, true_signature);
         if (cppmeth) {
-            void* fptr = (void*)Cppyy::GetFunctionAddress(cppmeth, false);
+            void* fptr = (void*)cppjit::interop::GetFunctionAddress(cppmeth, false);
             if (fptr) return fptr;
         }
         // FIXME: Should we fall-through, with calling through Python
@@ -2701,7 +2701,7 @@ static void* PyFunction_AsCPointer(PyObject* pyobject,
 
     if (PyObject_IsInstance(pyobject, (PyObject*)GetCTypesType(ct_c_funcptr))) {
     // ctypes function pointer
-        void* fptr = *(void**)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;
+        void* fptr = *(void**)((cpyrt_tagCDataObject*)pyobject)->b_ptr;
         return fptr;
     }
 
@@ -2750,14 +2750,14 @@ static void* PyFunction_AsCPointer(PyObject* pyobject,
 
        // build wrapper function code
             std::ostringstream code;
-            code << "namespace __cppyy_internal {\n  "
+            code << "namespace __cppjit_internal {\n  "
                  << rettype << " " << wname.str() << "(";
             for (int i = 0; i < nArgs; ++i) {
                 code << argtypes[i] << " arg" << i;
                 if (i != nArgs-1) code << ", ";
             }
             code << ") {\n"
-                << "    CPyCppyy::PythonGILRAII python_gil_raii;\n";
+                << "    cppjit::cpyrt::PythonGILRAII python_gil_raii;\n";
 
         // start function body
             Utility::ConstructCallbackPreamble(rettype, argtypes, code);
@@ -2781,13 +2781,13 @@ static void* PyFunction_AsCPointer(PyObject* pyobject,
             code << "}";
 
         // finally, compile the code
-            if (!Cppyy::Compile(code.str()))
+            if (!cppjit::interop::Compile(code.str()))
                 return nullptr;
 
         // TODO: is there no easier way?
-            static Cppyy::TCppScope_t scope = Cppyy::GetScope("__cppyy_internal");
-            const auto& methods = Cppyy::GetMethodsFromName(scope, wname.str());
-            wpraddress = Cppyy::GetFunctionAddress(methods[0], false);
+            static cppjit::interop::TCppScope_t scope = cppjit::interop::GetScope("__cppjit_internal");
+            const auto& methods = cppjit::interop::GetMethodsFromName(scope, wname.str());
+            wpraddress = cppjit::interop::GetFunctionAddress(methods[0], false);
             sWrapperReference[wpraddress] = ref;
 
         // cache the new wrapper
@@ -2804,7 +2804,7 @@ static void* PyFunction_AsCPointer(PyObject* pyobject,
     return nullptr;
 }
 
-bool CPyCppyy::FunctionPointerConverter::SetArg(
+bool cppjit::cpyrt::FunctionPointerConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // special case: allow nullptr singleton:
@@ -2826,7 +2826,7 @@ bool CPyCppyy::FunctionPointerConverter::SetArg(
     return false;
 }
 
-PyObject* CPyCppyy::FunctionPointerConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::FunctionPointerConverter::FromMemory(void* address)
 {
 // A function pointer in clang is represented by a Type, not a FunctionDecl and it's
 // not possible to get the latter from the former: the backend will need to support
@@ -2837,7 +2837,7 @@ PyObject* CPyCppyy::FunctionPointerConverter::FromMemory(void* address)
     return nullptr;
 }
 
-bool CPyCppyy::FunctionPointerConverter::ToMemory(
+bool cppjit::cpyrt::FunctionPointerConverter::ToMemory(
     PyObject* pyobject, void* address, PyObject* ctxt)
 {
 // special case: allow nullptr singleton:
@@ -2859,7 +2859,7 @@ bool CPyCppyy::FunctionPointerConverter::ToMemory(
 
 
 //- std::function converter --------------------------------------------------
-bool CPyCppyy::StdFunctionConverter::SetArg(
+bool cppjit::cpyrt::StdFunctionConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 // prefer normal "object" conversion
@@ -2886,12 +2886,12 @@ bool CPyCppyy::StdFunctionConverter::SetArg(
     return false;
 }
 
-PyObject* CPyCppyy::StdFunctionConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::StdFunctionConverter::FromMemory(void* address)
 {
     return fConverter->FromMemory(address);
 }
 
-bool CPyCppyy::StdFunctionConverter::ToMemory(PyObject* value, void* address, PyObject* ctxt)
+bool cppjit::cpyrt::StdFunctionConverter::ToMemory(PyObject* value, void* address, PyObject* ctxt)
 {
 // if the value is not an std::function<> but a generic Python callable, the
 // conversion is done through the assignment, which may involve a temporary
@@ -2901,7 +2901,7 @@ bool CPyCppyy::StdFunctionConverter::ToMemory(PyObject* value, void* address, Py
 
 
 //- smart pointer converters -------------------------------------------------
-bool CPyCppyy::SmartPtrConverter::SetArg(
+bool cppjit::cpyrt::SmartPtrConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
     char typeCode = fIsRef ? 'p' : 'V';
@@ -2918,11 +2918,11 @@ bool CPyCppyy::SmartPtrConverter::SetArg(
     }
 
     CPPInstance* pyobj = (CPPInstance*)pyobject;
-    Cppyy::TCppScope_t oisa = pyobj->ObjectIsA();
+    cppjit::interop::TCppScope_t oisa = pyobj->ObjectIsA();
 
 // for the case where we have a 'hidden' smart pointer:
-    if (Cppyy::TCppScope_t tsmart = pyobj->GetSmartIsA()) {
-        if (Cppyy::IsSubclass(tsmart, fSmartPtrType)) {
+    if (cppjit::interop::TCppScope_t tsmart = pyobj->GetSmartIsA()) {
+        if (cppjit::interop::IsSubclass(tsmart, fSmartPtrType)) {
         // depending on memory policy, some objects need releasing when passed into functions
             if (!fKeepControl && !UseStrictOwnership(ctxt))
                 ((CPPInstance*)pyobject)->CppOwns();
@@ -2930,7 +2930,7 @@ bool CPyCppyy::SmartPtrConverter::SetArg(
         // calculate offset between formal and actual arguments
             para.fValue.fVoidp = pyobj->GetSmartObject();
             if (tsmart != fSmartPtrType) {
-                para.fValue.fIntPtr += Cppyy::GetBaseOffset(
+                para.fValue.fIntPtr += cppjit::interop::GetBaseOffset(
                     tsmart, fSmartPtrType, para.fValue.fVoidp, 1 /* up-cast */);
             }
 
@@ -2941,11 +2941,11 @@ bool CPyCppyy::SmartPtrConverter::SetArg(
     }
 
 // for the case where we have an 'exposed' smart pointer:
-    if (!pyobj->IsSmart() && Cppyy::IsSubclass(oisa, fSmartPtrType)) {
+    if (!pyobj->IsSmart() && cppjit::interop::IsSubclass(oisa, fSmartPtrType)) {
     // calculate offset between formal and actual arguments
         para.fValue.fVoidp = pyobj->GetObject();
         if (oisa != fSmartPtrType) {
-            para.fValue.fIntPtr += Cppyy::GetBaseOffset(
+            para.fValue.fIntPtr += cppjit::interop::GetBaseOffset(
                 oisa, fSmartPtrType, para.fValue.fVoidp, 1 /* up-cast */);
         }
 
@@ -2955,7 +2955,7 @@ bool CPyCppyy::SmartPtrConverter::SetArg(
     }
 
 // for the case where we have an ordinary object to convert
-    if (!pyobj->IsSmart() && Cppyy::IsSubclass(oisa, fUnderlyingType)) {
+    if (!pyobj->IsSmart() && cppjit::interop::IsSubclass(oisa, fUnderlyingType)) {
     // create the relevant smart pointer and make the pyobject "smart"
         CPPInstance* pysmart = (CPPInstance*)ConvertImplicit(fSmartPtrType, pyobject, para, ctxt, false);
         if (!CPPInstance_Check(pysmart)) {
@@ -2977,7 +2977,7 @@ bool CPyCppyy::SmartPtrConverter::SetArg(
 // Match on the declared underlying type, not the (possibly downcast)
 // dereferenced object: a unique_ptr<Base> holding a Derived is still a
 // unique_ptr<Base> and must not pass where a unique_ptr<Derived> is expected.
-    if (pyobj->IsSmart() && Cppyy::IsSubclass(pyobj->GetSmartUnderlyingType(), fUnderlyingType)) {
+    if (pyobj->IsSmart() && cppjit::interop::IsSubclass(pyobj->GetSmartUnderlyingType(), fUnderlyingType)) {
         para.fValue.fVoidp = ((CPPInstance*)pyobject)->GetSmartObject();
         para.fTypeCode = 'V';
         return true;
@@ -2986,7 +2986,7 @@ bool CPyCppyy::SmartPtrConverter::SetArg(
     return false;
 }
 
-PyObject* CPyCppyy::SmartPtrConverter::FromMemory(void* address)
+PyObject* cppjit::cpyrt::SmartPtrConverter::FromMemory(void* address)
 {
     if (!address || !fSmartPtrType)
         return nullptr;
@@ -2994,7 +2994,7 @@ PyObject* CPyCppyy::SmartPtrConverter::FromMemory(void* address)
     return BindCppObjectNoCast(address, fSmartPtrType);
 }
 
-bool CPyCppyy::SmartPtrConverter::ToMemory(PyObject* value, void* address, PyObject*)
+bool cppjit::cpyrt::SmartPtrConverter::ToMemory(PyObject* value, void* address, PyObject*)
 {
 // assign value to C++ instance living at <address> through assignment operator (this
 // is similar to InstanceConverter::ToMemory, but prevents wrapping the smart ptr)
@@ -3035,16 +3035,16 @@ struct faux_initlist
 
 } // unnamed namespace
 
-CPyCppyy::InitializerListConverter::InitializerListConverter(Cppyy::TCppScope_t klass, std::string const &value_type)
+cppjit::cpyrt::InitializerListConverter::InitializerListConverter(cppjit::interop::TCppScope_t klass, std::string const &value_type)
 
     : InstanceConverter{klass},
       fValueTypeName{value_type},
-      fValueType{Cppyy::GetScope(value_type)},
-      fValueSize{Cppyy::SizeOfType(Cppyy::GetType(value_type, true))}
+      fValueType{cppjit::interop::GetScope(value_type)},
+      fValueSize{cppjit::interop::SizeOfType(cppjit::interop::GetType(value_type, true))}
 {
 }
 
-CPyCppyy::InitializerListConverter::~InitializerListConverter()
+cppjit::cpyrt::InitializerListConverter::~InitializerListConverter()
 {
     for (Converter *converter : fConverters) {
        if (converter && converter->HasState()) delete converter;
@@ -3052,7 +3052,7 @@ CPyCppyy::InitializerListConverter::~InitializerListConverter()
     if (fBuffer) Clear();
 }
 
-void CPyCppyy::InitializerListConverter::Clear() {
+void cppjit::cpyrt::InitializerListConverter::Clear() {
     if (fValueType) {
         faux_initlist* fake = (faux_initlist*)fBuffer;
 #if defined (_LIBCPP_INITIALIZER_LIST) || defined(__GNUC__)
@@ -3061,7 +3061,7 @@ void CPyCppyy::InitializerListConverter::Clear() {
         for (size_t i = 0; (fake->_M_array+i*fValueSize) != fake->_Last; ++i) {
 #endif
             void* memloc = (char*)fake->_M_array + i*fValueSize;
-            Cppyy::CallDestructor(fValueType, (Cppyy::TCppObject_t)memloc);
+            cppjit::interop::CallDestructor(fValueType, (cppjit::interop::TCppObject_t)memloc);
         }
     }
 
@@ -3069,7 +3069,7 @@ void CPyCppyy::InitializerListConverter::Clear() {
     fBuffer = nullptr;
 }
 
-bool CPyCppyy::InitializerListConverter::SetArg(
+bool cppjit::cpyrt::InitializerListConverter::SetArg(
     PyObject* pyobject, Parameter& para, CallContext* ctxt)
 {
 #ifdef NO_KNOWN_INITIALIZER_LIST
@@ -3080,7 +3080,7 @@ bool CPyCppyy::InitializerListConverter::SetArg(
 // convert the given argument to an initializer list temporary; this is purely meant
 // to be a syntactic thing, so only _python_ sequences are allowed; bound C++ proxies
 // (likely explicitly created std::initializer_list, go through an instance converter
-    if (!PySequence_Check(pyobject) || CPyCppyy_PyText_Check(pyobject) || PyBytes_Check(pyobject)
+    if (!PySequence_Check(pyobject) || cpyrt_PyText_Check(pyobject) || PyBytes_Check(pyobject)
         )
         return false;
 
@@ -3110,7 +3110,7 @@ bool CPyCppyy::InitializerListConverter::SetArg(
 
     // Can only construct empty lists, so use a fake initializer list. For that we
     // need to construct default objects. Fail early if that cannot work.
-        if (fValueType && !Cppyy::IsDefaultConstructable(fValueType)) {
+        if (fValueType && !cppjit::interop::IsDefaultConstructable(fValueType)) {
             PyErr_SetString(PyExc_TypeError, "default constructor needed for initializer list of objects");
             return false;
         }
@@ -3143,7 +3143,7 @@ bool CPyCppyy::InitializerListConverter::SetArg(
                     // we need to construct a default object for the constructor to assign into; this is
                     // clunky, but the use of a copy constructor isn't much better as the Python object
                     // need not be a C++ object
-                        memloc = (void*)Cppyy::Construct(fValueType, memloc).data;
+                        memloc = (void*)cppjit::interop::Construct(fValueType, memloc).data;
                     // We checked above that we are able to construct default objects of fValueType.
                         assert(memloc && ("failed to default construct object for type " + fValueTypeName).c_str());
                         entries += 1;
@@ -3180,7 +3180,7 @@ bool CPyCppyy::InitializerListConverter::SetArg(
 #endif
 }
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 // raising converter to take out overloads
 class NotImplementedConverter : public Converter {
@@ -3192,10 +3192,10 @@ class NotImplementedConverter : public Converter {
     std::string fMessage;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::NotImplementedConverter::SetArg(PyObject*, Parameter&, CallContext*)
+bool cppjit::cpyrt::NotImplementedConverter::SetArg(PyObject*, Parameter&, CallContext*)
 {
 // raise a NotImplemented exception to take a method out of overload resolution
     PyErr_SetString(fErrorType, fMessage.c_str());
@@ -3204,10 +3204,10 @@ bool CPyCppyy::NotImplementedConverter::SetArg(PyObject*, Parameter&, CallContex
 
 
 //- helper to refactor some code from CreateConverter ------------------------
-static inline CPyCppyy::Converter* selectInstanceCnv(Cppyy::TCppScope_t klass,
-        const std::string& cpd, CPyCppyy::cdims_t dims, bool isConst, bool control)
+static inline cppjit::cpyrt::Converter* selectInstanceCnv(cppjit::interop::TCppScope_t klass,
+        const std::string& cpd, cppjit::cpyrt::cdims_t dims, bool isConst, bool control)
 {
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
     Converter* result = nullptr;
 
     if (cpd == "**" || cpd == "*[]" || cpd == "&*")
@@ -3231,8 +3231,8 @@ static inline CPyCppyy::Converter* selectInstanceCnv(Cppyy::TCppScope_t klass,
 }
 
 //- factories ----------------------------------------------------------------
-CPYCPPYY_EXPORT
-CPyCppyy::Converter* CPyCppyy::CreateConverter(const std::string& fullType, cdims_t dims)
+CPYRT_EXPORT
+cppjit::cpyrt::Converter* cppjit::cpyrt::CreateConverter(const std::string& fullType, cdims_t dims)
 {
 // The matching of the fulltype to a converter factory goes through up to five levels:
 //   1) full, exact match
@@ -3250,7 +3250,7 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(const std::string& fullType, cdim
     }
 
 // resolve typedefs etc.
-    const std::string& resolvedType = Cppyy::ResolveName(fullType);
+    const std::string& resolvedType = cppjit::interop::ResolveName(fullType);
 
 // a full, qualified matching converter is preferred
     if (resolvedType != fullType) {
@@ -3327,7 +3327,7 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(const std::string& fullType, cdim
     // get the type of the list and create a converter (TODO: get hold of value_type?)
         auto pos = realType.find('<');
         std::string value_type = realType.substr(pos+1, realType.size()-pos-2);
-        return new InitializerListConverter(Cppyy::GetScope(realType), value_type);
+        return new InitializerListConverter(cppjit::interop::GetScope(realType), value_type);
     }
 
 //-- still nothing? use a generalized converter
@@ -3339,7 +3339,7 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(const std::string& fullType, cdim
 
     // get actual converter for normal passing
         Converter* cnv = selectInstanceCnv(
-            Cppyy::GetScope(realType), cpd, dims, isConst, control);
+            cppjit::interop::GetScope(realType), cpd, dims, isConst, control);
 
         if (cnv) {
         // get the type of the underlying (TODO: use target_type?)
@@ -3363,11 +3363,11 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(const std::string& fullType, cdim
         pos == 6 /* const no std:: */ || pos == 11 /* const with std:: */ ) {
 
         // std::span<T>::value_type == std::remove_cv_t<T>: look it up
-        Cppyy::TCppScope_t span_scope = Cppyy::GetScope(realType);
-        Cppyy::TCppType_t  vtype = Cppyy::ResolveType(
-            Cppyy::GetTypeFromScope(Cppyy::GetNamed("value_type", span_scope)));
+        cppjit::interop::TCppScope_t span_scope = cppjit::interop::GetScope(realType);
+        cppjit::interop::TCppType_t  vtype = cppjit::interop::ResolveType(
+            cppjit::interop::GetTypeFromScope(cppjit::interop::GetNamed("value_type", span_scope)));
         if (span_scope && vtype) {
-            std::string value_type = Cppyy::GetTypeAsString(vtype);
+            std::string value_type = cppjit::interop::GetTypeAsString(vtype);
             return new StdSpanConverter{value_type, span_scope};
         }
     }
@@ -3375,9 +3375,9 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(const std::string& fullType, cdim
 
 // converters for known C++ classes and default (void*)
     Converter* result = nullptr;
-    if (Cppyy::TCppScope_t klass = Cppyy::GetFullScope(realType)) {
-        Cppyy::TCppScope_t raw;
-        if (Cppyy::GetSmartPtrInfo(realType, &raw, nullptr)) {
+    if (cppjit::interop::TCppScope_t klass = cppjit::interop::GetFullScope(realType)) {
+        cppjit::interop::TCppScope_t raw;
+        if (cppjit::interop::GetSmartPtrInfo(realType, &raw, nullptr)) {
             if (cpd == "") {
                 result = new SmartPtrConverter(klass, raw, control);
             } else if (cpd == "&") {
@@ -3434,8 +3434,8 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(const std::string& fullType, cdim
     return result;
 }
 
-CPYCPPYY_EXPORT
-CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t dims)
+CPYRT_EXPORT
+cppjit::cpyrt::Converter* cppjit::cpyrt::CreateConverter(cppjit::interop::TCppType_t type, cdims_t dims)
 {
 // The matching of the fulltype to a converter factory goes through up to five levels:
 //   1) full, exact match
@@ -3447,15 +3447,15 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
 // If all fails, void is used, which will generate a run-time warning when used.
 
 // an exactly matching converter is best
-    std::string fullType = Cppyy::GetTypeAsString(type);
+    std::string fullType = cppjit::interop::GetTypeAsString(type);
     ConvFactories_t::iterator h = gConvFactories.find(fullType);
     if (h != gConvFactories.end()) {
         return (h->second)(dims);
     }
 
 // resolve typedefs etc.
-    Cppyy::TCppType_t resolvedType = Cppyy::ResolveType(type);
-    const std::string& resolvedTypeStr = Cppyy::GetTypeAsString(resolvedType);
+    cppjit::interop::TCppType_t resolvedType = cppjit::interop::ResolveType(type);
+    const std::string& resolvedTypeStr = cppjit::interop::GetTypeAsString(resolvedType);
 
 // a full, qualified matching converter is preferred
     if (resolvedTypeStr != fullType) {
@@ -3468,8 +3468,8 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
 //-- nothing? ok, collect information about the type and possible qualifiers/decorators
     bool isConst = strncmp(resolvedTypeStr.c_str(), "const", 5) == 0;
     const std::string& cpd = TypeManip::compound(resolvedTypeStr);
-    Cppyy::TCppType_t realType = Cppyy::ResolveType(Cppyy::GetRealType(type));
-    std::string realTypeStr   = Cppyy::GetTypeAsString(realType);
+    cppjit::interop::TCppType_t realType = cppjit::interop::ResolveType(cppjit::interop::GetRealType(type));
+    std::string realTypeStr   = cppjit::interop::GetTypeAsString(realType);
     std::string realUnresolvedTypeStr   = TypeManip::clean_type(fullType, false, true);
 
 // accept unqualified type (as python does not know about qualifiers)
@@ -3537,7 +3537,7 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
         auto pos = realTypeStr.find('<');
         std::string value_type = realTypeStr.substr(pos+1, realTypeStr.size()-pos-2);
         Converter* cnv = nullptr; bool use_byte_cnv = false;
-        if (cpd == "" && Cppyy::GetScope(value_type)) {
+        if (cpd == "" && cppjit::interop::GetScope(value_type)) {
         // initializer list of object values does not work as the target is raw
         // memory; simply use byte copies
 
@@ -3546,7 +3546,7 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
         } else
             cnv = CreateConverter(value_type);
         if (cnv || use_byte_cnv)
-            return new InitializerListConverter(Cppyy::GetScopeFromType(realType), value_type);
+            return new InitializerListConverter(cppjit::interop::GetScopeFromType(realType), value_type);
     }
 
 //-- still nothing? use a generalized converter
@@ -3558,7 +3558,7 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
 
     // get actual converter for normal passing
         Converter* cnv = selectInstanceCnv(
-            Cppyy::GetScopeFromType(realType), cpd, dims, isConst, control);
+            cppjit::interop::GetScopeFromType(realType), cpd, dims, isConst, control);
 
         if (cnv) {
         // get the type of the underlying (TODO: use target_type?)
@@ -3583,11 +3583,11 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
         pos == 6 /* const no std:: */ || pos == 11 /* const with std:: */ ) {
 
         // std::span<T>::value_type == std::remove_cv_t<T>: look it up
-        Cppyy::TCppScope_t span_scope = Cppyy::GetScopeFromType(realType);
-        Cppyy::TCppType_t  vtype = Cppyy::ResolveType(
-            Cppyy::GetTypeFromScope(Cppyy::GetNamed("value_type", span_scope)));
+        cppjit::interop::TCppScope_t span_scope = cppjit::interop::GetScopeFromType(realType);
+        cppjit::interop::TCppType_t  vtype = cppjit::interop::ResolveType(
+            cppjit::interop::GetTypeFromScope(cppjit::interop::GetNamed("value_type", span_scope)));
         if (span_scope && vtype) {
-            std::string value_type = Cppyy::GetTypeAsString(vtype);
+            std::string value_type = cppjit::interop::GetTypeAsString(vtype);
             return new StdSpanConverter{value_type, span_scope};
         }
     }
@@ -3595,7 +3595,7 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
 
 // converters for known C++ classes and default (void*)
     Converter* result = nullptr;
-    Cppyy::TCppScope_t klass = Cppyy::GetScopeFromType(realType);
+    cppjit::interop::TCppScope_t klass = cppjit::interop::GetScopeFromType(realType);
     if (resolvedTypeStr.find("(*)") != std::string::npos ||
                (resolvedTypeStr.find("::*)") != std::string::npos)) {
     // this is a function function pointer
@@ -3606,10 +3606,10 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
         std::string return_type = resolvedTypeStr.substr(0, pos1);
         result = new FunctionPointerConverter(
             return_type.erase(return_type.find_last_not_of(" ") + 1), resolvedTypeStr.substr(pos2+2, pos3-pos2-1));
-    } else if ((realTypeStr != "std::byte") && (klass || (klass = Cppyy::GetFullScope(realTypeStr)))) {
+    } else if ((realTypeStr != "std::byte") && (klass || (klass = cppjit::interop::GetFullScope(realTypeStr)))) {
         // std::byte is a special enum class used to access raw memory
-        Cppyy::TCppScope_t raw;
-        if (Cppyy::GetSmartPtrInfo(realTypeStr, &raw, nullptr)) {
+        cppjit::interop::TCppScope_t raw;
+        if (cppjit::interop::GetSmartPtrInfo(realTypeStr, &raw, nullptr)) {
             if (cpd == "") {
                 result = new SmartPtrConverter(klass, raw, control);
             } else if (cpd == "&") {
@@ -3668,16 +3668,16 @@ CPyCppyy::Converter* CPyCppyy::CreateConverter(Cppyy::TCppType_t type, cdims_t d
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-void CPyCppyy::DestroyConverter(Converter* p)
+CPYRT_EXPORT
+void cppjit::cpyrt::DestroyConverter(Converter* p)
 {
     if (p && p->HasState())
         delete p;  // state-less converters are always shared
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-bool CPyCppyy::RegisterConverter(const std::string& name, cf_t fac)
+CPYRT_EXPORT
+bool cppjit::cpyrt::RegisterConverter(const std::string& name, cf_t fac)
 {
 // register a custom converter
     auto f = gConvFactories.find(name);
@@ -3689,8 +3689,8 @@ bool CPyCppyy::RegisterConverter(const std::string& name, cf_t fac)
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-bool CPyCppyy::RegisterConverterAlias(const std::string& name, const std::string& target)
+CPYRT_EXPORT
+bool cppjit::cpyrt::RegisterConverterAlias(const std::string& name, const std::string& target)
 {
 // register a custom converter that is a reference to an existing converter
     auto f = gConvFactories.find(name);
@@ -3706,8 +3706,8 @@ bool CPyCppyy::RegisterConverterAlias(const std::string& name, const std::string
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-bool CPyCppyy::UnregisterConverter(const std::string& name)
+CPYRT_EXPORT
+bool cppjit::cpyrt::UnregisterConverter(const std::string& name)
 {
 // remove a custom converter
     auto f = gConvFactories.find(name);
@@ -3722,7 +3722,7 @@ bool CPyCppyy::UnregisterConverter(const std::string& name)
 //----------------------------------------------------------------------------
 namespace {
 
-using namespace CPyCppyy;
+using namespace cppjit::cpyrt;
 
 inline static
 std::string::size_type dims2stringsz(cdims_t d) {
@@ -3746,7 +3746,7 @@ static struct InitConvFactories_t {
 public:
     InitConvFactories_t() {
     // load all converter factories in the global map 'gConvFactories'
-        CPyCppyy::ConvFactories_t& gf = gConvFactories;
+        cppjit::cpyrt::ConvFactories_t& gf = gConvFactories;
 
     // factories for built-ins
         gf["bool"] =                        (cf_t)+[](cdims_t) { static BoolConverter c{};           return &c; };
@@ -3870,7 +3870,7 @@ static struct InitConvFactories_t {
         gf[CCOMPLEX_F " ptr"] =             gf["std::complex<float> ptr"];
         gf[CCOMPLEX_D " ptr"] =             gf["std::complex<double> ptr"];
 
-        // We always need these converters when cppyy is based on an unpatched
+        // We always need these converters when cppjit is based on an unpatched
         // ROOT, because the "long long" types are always converted to Long64_t
         // and ULong64_t already at the ROOT Meta level.
         // See https://github.com/root-project/root/issues/15872#issuecomment-2174092763
@@ -3896,7 +3896,7 @@ static struct InitConvFactories_t {
      // TODO: The libc++ library that is used most prominently by Apple for
      // macOS is using the _Nonnull Clang attribute for some of its string
      // constructors (_LIBCPP_DIAGNOSE_NULLPTR is a preprocessor macro that
-     // resolves to _Nullable). The cppyy backend doesn't strip away such Clang
+     // resolves to _Nullable). The cppjit backend doesn't strip away such Clang
      // attributes, so the wchar_t* converter fails to match. To make the
      // construction of std::wstring work on macOS, we are explicitly creating
      // a converter for the wchar_t*_Nonnull type here, but we should try to
diff --git a/src/CPyCppyy/src/Converters.h b/src/cpyrt/Converters.h
similarity index 70%
rename from src/CPyCppyy/src/Converters.h
rename to src/cpyrt/Converters.h
index 6560e79..3d86a86 100644
--- a/src/CPyCppyy/src/Converters.h
+++ b/src/cpyrt/Converters.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_CONVERTERS_H
-#define CPYCPPYY_CONVERTERS_H
+#ifndef CPYRT_CONVERTERS_H
+#define CPYRT_CONVERTERS_H
 
 // Bindings
 #include "Dimensions.h"
@@ -8,12 +8,12 @@
 #include <string>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 struct Parameter;
 struct CallContext;
 
-class CPYCPPYY_CLASS_EXPORT Converter {
+class CPYRT_CLASS_EXPORT Converter {
 public:
     virtual ~Converter();
 
@@ -33,13 +33,13 @@ class CPYCPPYY_CLASS_EXPORT Converter {
 };
 
 // create/destroy converter from fully qualified type (public API)
-CPYCPPYY_EXPORT Converter* CreateConverter(const std::string& fullType, cdims_t dims = 0);
-CPYCPPYY_EXPORT Converter* CreateConverter(Cppyy::TCppType_t type, cdims_t dims = 0);
-CPYCPPYY_EXPORT void DestroyConverter(Converter* p);
+CPYRT_EXPORT Converter* CreateConverter(const std::string& fullType, cdims_t dims = 0);
+CPYRT_EXPORT Converter* CreateConverter(cppjit::interop::TCppType_t type, cdims_t dims = 0);
+CPYRT_EXPORT void DestroyConverter(Converter* p);
 typedef Converter* (*cf_t)(cdims_t d);
-CPYCPPYY_EXPORT bool RegisterConverter(const std::string& name, cf_t fac);
-CPYCPPYY_EXPORT bool RegisterConverterAlias(const std::string& name, const std::string& target);
-CPYCPPYY_EXPORT bool UnregisterConverter(const std::string& name);
+CPYRT_EXPORT bool RegisterConverter(const std::string& name, cf_t fac);
+CPYRT_EXPORT bool RegisterConverterAlias(const std::string& name, const std::string& target);
+CPYRT_EXPORT bool UnregisterConverter(const std::string& name);
 
 
 // converters for special cases (only here b/c of external use of StrictInstancePtrConverter)
@@ -67,8 +67,8 @@ class VoidArrayConverter : public Converter {
 template <bool ISCONST>
 class InstancePtrConverter : public VoidArrayConverter {
 public:
-    InstancePtrConverter(Cppyy::TCppScope_t klass, bool keepControl = false, const std::string &failureMsg = std::string()) :
-        VoidArrayConverter(keepControl, failureMsg), fClass(Cppyy::GetUnderlyingScope(klass)) {}
+    InstancePtrConverter(cppjit::interop::TCppScope_t klass, bool keepControl = false, const std::string &failureMsg = std::string()) :
+        VoidArrayConverter(keepControl, failureMsg), fClass(cppjit::interop::GetUnderlyingScope(klass)) {}
 
 public:
     bool SetArg(PyObject*, Parameter&, CallContext* = nullptr) override;
@@ -76,7 +76,7 @@ class InstancePtrConverter : public VoidArrayConverter {
     bool ToMemory(PyObject* value, void* address, PyObject* ctxt = nullptr) override;
 
 protected:
-    Cppyy::TCppScope_t fClass;
+    cppjit::interop::TCppScope_t fClass;
 };
 
 class StrictInstancePtrConverter : public InstancePtrConverter<false> {
@@ -87,6 +87,6 @@ class StrictInstancePtrConverter : public InstancePtrConverter<false> {
     bool GetAddressSpecialCase(PyObject*, void*&) override { return false; }
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CONVERTERS_H
+#endif // !CPYRT_CONVERTERS_H
diff --git a/src/CPyCppyy/src/CustomPyTypes.cxx b/src/cpyrt/CustomPyTypes.cxx
similarity index 90%
rename from src/CPyCppyy/src/CustomPyTypes.cxx
rename to src/cpyrt/CustomPyTypes.cxx
index 4038947..671551a 100644
--- a/src/CPyCppyy/src/CustomPyTypes.cxx
+++ b/src/cpyrt/CustomPyTypes.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CustomPyTypes.h"
 #include "CPPInstance.h"
 #include "Converters.h"
@@ -16,7 +16,7 @@
 // TODO: this will break functionality
 #define CustomInstanceMethod_GET_CLASS(meth) Py_None
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 //- custom type representing typedef to pointer of class ---------------------
 static PyObject* tptc_call(typedefpointertoclassobject* self, PyObject* args, PyObject* /* kwds */)
@@ -24,27 +24,27 @@ static PyObject* tptc_call(typedefpointertoclassobject* self, PyObject* args, Py
     long long addr = 0;
     if (!PyArg_ParseTuple(args, const_cast<char*>("|L"), &addr))
         return nullptr;
-    return BindCppObjectNoCast(Cppyy::TCppObject_t((void*)addr), self->fCppType);
+    return BindCppObjectNoCast(cppjit::interop::TCppObject_t((void*)addr), self->fCppType);
 }
 
 //-----------------------------------------------------------------------------
 static PyObject* tptc_getcppname(typedefpointertoclassobject* self, void*)
 {
-    return CPyCppyy_PyText_FromString(
-        (Cppyy::GetScopedFinalName(self->fCppType)+"*").c_str());
+    return cpyrt_PyText_FromString(
+        (cppjit::interop::GetScopedFinalName(self->fCppType)+"*").c_str());
 }
 
 //-----------------------------------------------------------------------------
 static PyObject* tptc_name(typedefpointertoclassobject* self, void*)
 {
-    PyObject* pyclass = CPyCppyy::GetScopeProxy(self->fCppType);
+    PyObject* pyclass = cppjit::cpyrt::GetScopeProxy(self->fCppType);
     if (pyclass) {
         PyObject* pyname = PyObject_GetAttr(pyclass, PyStrings::gName);
         Py_DECREF(pyclass);
         return pyname;
     }
 
-    return CPyCppyy_PyText_FromString("<unknown>*");
+    return cpyrt_PyText_FromString("<unknown>*");
 }
 
 //-----------------------------------------------------------------------------
@@ -57,7 +57,7 @@ static PyGetSetDef tptc_getset[] = {
 
 PyTypeObject TypedefPointerToClass_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.TypedefPointerToClass",// tp_name
+    (char*)"cppjit.TypedefPointerToClass",// tp_name
     sizeof(typedefpointertoclassobject), // tp_basicsize
     0,                              // tp_itemsize
     0,                              // tp_dealloc
@@ -105,7 +105,7 @@ PyTypeObject TypedefPointerToClass_Type = {
     0,                              // tp_version_tag
     0,                              // tp_finalize
     0                               // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
 //= instancemethod object with a more efficient call function ================
@@ -206,7 +206,7 @@ static PyObject* im_call(PyObject* meth, PyObject* args, PyObject* kw)
 // the function is globally shared, so set and reset its "self" (ok, b/c of GIL)
     Py_INCREF(self);
     func->m_self = self;
-    PyObject* result = CPyCppyy_PyCFunction_Call((PyObject*)func, args, kw);
+    PyObject* result = cpyrt_PyCFunction_Call((PyObject*)func, args, kw);
     func->m_self = nullptr;
     Py_DECREF(self);
     Py_DECREF(args);
@@ -229,10 +229,10 @@ static PyObject* im_descr_get(PyObject* meth, PyObject* obj, PyObject* pyclass)
     return CustomInstanceMethod_New(CustomInstanceMethod_GET_FUNCTION(meth), obj, pyclass);
 }
 
-//= CPyCppyy custom instance method type =====================================
+//= cpyrt custom instance method type =====================================
 PyTypeObject CustomInstanceMethod_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.InstanceMethod", // tp_name
+    (char*)"cppjit.InstanceMethod", // tp_name
     0, 0,
     (destructor)im_dealloc,        // tp_dealloc
     0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -240,7 +240,7 @@ PyTypeObject CustomInstanceMethod_Type = {
     0, 0, 0, 0,
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
         Py_TPFLAGS_BASETYPE,       // tp_flags
-    (char*)"CPyCppyy custom instance method (internal)",    // tp_doc
+    (char*)"cpyrt custom instance method (internal)",    // tp_doc
     0, 0, 0, 0, 0, 0, 0, 0, 0,
     &PyMethod_Type,                // tp_base
     0,
@@ -250,11 +250,11 @@ PyTypeObject CustomInstanceMethod_Type = {
     0,                             // tp_version_tag
     0,                             // tp_finalize
     0                              // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
 
-//= CPyCppyy custom iterator for performance =================================
+//= cpyrt custom iterator for performance =================================
 static void indexiter_dealloc(indexiterobject* ii) {
     PyObject_GC_UnTrack(ii);
     Py_XDECREF(ii->ii_container);
@@ -280,7 +280,7 @@ static PyObject* indexiter_iternext(indexiterobject* ii) {
 
 PyTypeObject IndexIter_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.indexiter",     // tp_name
+    (char*)"cppjit.indexiter",     // tp_name
     sizeof(indexiterobject),      // tp_basicsize
     0,
     (destructor)indexiter_dealloc,     // tp_dealloc
@@ -297,7 +297,7 @@ PyTypeObject IndexIter_Type = {
     0,                            // tp_version_tag
     0,                            // tp_finalize
     0                             // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
 
@@ -319,11 +319,11 @@ static PyObject* vectoriter_iternext(vectoriterobject* vi) {
     // The CPPInstance::kNoMemReg by-passes the memory regulator; the assumption here is
     // that objects in vectors are simple and thus do not need to maintain object identity
     // (or at least not during the loop anyway). This gains 2x in performance.
-        Cppyy::TCppObject_t cppobj((void*)((ptrdiff_t)vi->vi_data + vi->vi_stride * vi->ii_pos));
+        cppjit::interop::TCppObject_t cppobj((void*)((ptrdiff_t)vi->vi_data + vi->vi_stride * vi->ii_pos));
         if (vi->vi_flags & vectoriterobject::kIsPolymorphic)
-            result = CPyCppyy::BindCppObject(*(void**)cppobj.data, vi->vi_klass, CPyCppyy::CPPInstance::kNoMemReg);
+            result = cppjit::cpyrt::BindCppObject(*(void**)cppobj.data, vi->vi_klass, cppjit::cpyrt::CPPInstance::kNoMemReg);
         else
-            result = CPyCppyy::BindCppObjectNoCast(cppobj, vi->vi_klass, CPyCppyy::CPPInstance::kNoMemReg);
+            result = cppjit::cpyrt::BindCppObjectNoCast(cppobj, vi->vi_klass, cppjit::cpyrt::CPPInstance::kNoMemReg);
         if ((vi->vi_flags & vectoriterobject::kNeedLifeLine) && result)
             PyObject_SetAttr(result, PyStrings::gLifeLine, vi->ii_container);
     } else {
@@ -338,7 +338,7 @@ static PyObject* vectoriter_iternext(vectoriterobject* vi) {
 
 PyTypeObject VectorIter_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.vectoriter",    // tp_name
+    (char*)"cppjit.vectoriter",    // tp_name
     sizeof(vectoriterobject),     // tp_basicsize
     0,
     (destructor)vectoriter_dealloc,         // tp_dealloc
@@ -355,7 +355,7 @@ PyTypeObject VectorIter_Type = {
     0,                            // tp_version_tag
     0,                            // tp_finalize
     0                             // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
diff --git a/src/CPyCppyy/src/CustomPyTypes.h b/src/cpyrt/CustomPyTypes.h
similarity index 84%
rename from src/CPyCppyy/src/CustomPyTypes.h
rename to src/cpyrt/CustomPyTypes.h
index 6e72ac8..bc55349 100644
--- a/src/CPyCppyy/src/CustomPyTypes.h
+++ b/src/cpyrt/CustomPyTypes.h
@@ -1,10 +1,10 @@
-#ifndef CPYCPPYY_CUSTOMPYTYPES_H
-#define CPYCPPYY_CUSTOMPYTYPES_H
+#ifndef CPYRT_CUSTOMPYTYPES_H
+#define CPYRT_CUSTOMPYTYPES_H
 
 #include "Python.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 /** Custom "builtins," detectable by type, for pass by ref and improved
     performance.
@@ -13,7 +13,7 @@ namespace CPyCppyy {
 //- custom type representing typedef to pointer of class ---------------------
 struct typedefpointertoclassobject {
     PyObject_HEAD
-    Cppyy::TCppScope_t fCppType;
+    cppjit::interop::TCppScope_t fCppType;
 };
 
 extern PyTypeObject TypedefPointerToClass_Type;
@@ -61,8 +61,8 @@ class Converter;
 struct vectoriterobject : public indexiterobject {
     void*                    vi_data;
     Py_ssize_t               vi_stride;
-    CPyCppyy::Converter*     vi_converter;
-    Cppyy::TCppScope_t        vi_klass;
+    cppjit::cpyrt::Converter*     vi_converter;
+    cppjit::interop::TCppScope_t        vi_klass;
     int                      vi_flags;
 
     enum EFlags {
@@ -74,6 +74,6 @@ struct vectoriterobject : public indexiterobject {
 
 extern PyTypeObject VectorIter_Type;
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_CUSTOMPYTYPES_H
+#endif // !CPYRT_CUSTOMPYTYPES_H
diff --git a/src/CPyCppyy/src/DeclareConverters.h b/src/cpyrt/DeclareConverters.h
similarity index 81%
rename from src/CPyCppyy/src/DeclareConverters.h
rename to src/cpyrt/DeclareConverters.h
index 478f816..0afba60 100644
--- a/src/CPyCppyy/src/DeclareConverters.h
+++ b/src/cpyrt/DeclareConverters.h
@@ -1,9 +1,9 @@
-#ifndef CPYCPPYY_DECLARECONVERTERS_H
-#define CPYCPPYY_DECLARECONVERTERS_H
+#ifndef CPYRT_DECLARECONVERTERS_H
+#define CPYRT_DECLARECONVERTERS_H
 
 // Bindings
 #include "Converters.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "Dimensions.h"
 
 // Standard
@@ -11,11 +11,11 @@
 #include <string>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 namespace {
 
-#define CPPYY_DECLARE_BASIC_CONVERTER(name)                                  \
+#define CPPJIT_DECLARE_BASIC_CONVERTER(name)                                  \
 class name##Converter : public Converter {                                   \
 public:                                                                      \
     bool SetArg(PyObject*, Parameter&, CallContext* = nullptr) override;      \
@@ -32,7 +32,7 @@ public:                                                                      \
 }
 
 
-#define CPPYY_DECLARE_BASIC_CONVERTER2(name, base)                           \
+#define CPPJIT_DECLARE_BASIC_CONVERTER2(name, base)                           \
 class name##Converter : public base##Converter {                             \
 public:                                                                      \
     PyObject* FromMemory(void*) override;                                     \
@@ -47,7 +47,7 @@ public:                                                                      \
     std::string GetFailureMsg() override { return "[Const" #name "RefConverter]"; }\
 }
 
-#define CPPYY_DECLARE_REFCONVERTER(name)                                     \
+#define CPPJIT_DECLARE_REFCONVERTER(name)                                     \
 class name##RefConverter : public Converter {                                \
 public:                                                                      \
     bool SetArg(PyObject*, Parameter&, CallContext* = nullptr) override;      \
@@ -55,7 +55,7 @@ public:                                                                      \
     std::string GetFailureMsg() override { return "[" #name "RefConverter]"; }\
 };
 
-#define CPPYY_DECLARE_ARRAY_CONVERTER(name)                                  \
+#define CPPJIT_DECLARE_ARRAY_CONVERTER(name)                                  \
 class name##ArrayConverter : public Converter {                              \
 public:                                                                      \
     name##ArrayConverter(cdims_t dims);                                      \
@@ -73,56 +73,56 @@ protected:                                                                   \
 
 
 // converters for built-ins
-CPPYY_DECLARE_BASIC_CONVERTER(Long);
-CPPYY_DECLARE_BASIC_CONVERTER(Bool);
-CPPYY_DECLARE_BASIC_CONVERTER(Char);
+CPPJIT_DECLARE_BASIC_CONVERTER(Long);
+CPPJIT_DECLARE_BASIC_CONVERTER(Bool);
+CPPJIT_DECLARE_BASIC_CONVERTER(Char);
 class SCharAsIntConverter : public CharConverter {
 public:
     using CharConverter::CharConverter;
     PyObject* FromMemory(void*) override;
 };
-CPPYY_DECLARE_BASIC_CONVERTER(UChar);
+CPPJIT_DECLARE_BASIC_CONVERTER(UChar);
 class UCharAsIntConverter : public UCharConverter {
 public:
     using UCharConverter::UCharConverter;
     PyObject* FromMemory(void*) override;
 };
-CPPYY_DECLARE_BASIC_CONVERTER(WChar);
-CPPYY_DECLARE_BASIC_CONVERTER(Char16);
-CPPYY_DECLARE_BASIC_CONVERTER(Char32);
-CPPYY_DECLARE_BASIC_CONVERTER(Int8);
-CPPYY_DECLARE_BASIC_CONVERTER(UInt8);
-CPPYY_DECLARE_BASIC_CONVERTER(Short);
-CPPYY_DECLARE_BASIC_CONVERTER(UShort);
-CPPYY_DECLARE_BASIC_CONVERTER(Int);
-CPPYY_DECLARE_BASIC_CONVERTER(ULong);
-CPPYY_DECLARE_BASIC_CONVERTER2(UInt, ULong);
-CPPYY_DECLARE_BASIC_CONVERTER(LLong);
-CPPYY_DECLARE_BASIC_CONVERTER(ULLong);
-CPPYY_DECLARE_BASIC_CONVERTER(Double);
-CPPYY_DECLARE_BASIC_CONVERTER(Float);
-CPPYY_DECLARE_BASIC_CONVERTER(LDouble);
-
-CPPYY_DECLARE_REFCONVERTER(Bool);
-CPPYY_DECLARE_REFCONVERTER(Char);
-CPPYY_DECLARE_REFCONVERTER(WChar);
-CPPYY_DECLARE_REFCONVERTER(Char16);
-CPPYY_DECLARE_REFCONVERTER(Char32);
-CPPYY_DECLARE_REFCONVERTER(SChar);
-CPPYY_DECLARE_REFCONVERTER(UChar);
-CPPYY_DECLARE_REFCONVERTER(Int8);
-CPPYY_DECLARE_REFCONVERTER(UInt8);
-CPPYY_DECLARE_REFCONVERTER(Short);
-CPPYY_DECLARE_REFCONVERTER(UShort);
-CPPYY_DECLARE_REFCONVERTER(UInt);
-CPPYY_DECLARE_REFCONVERTER(Int);
-CPPYY_DECLARE_REFCONVERTER(Long);
-CPPYY_DECLARE_REFCONVERTER(ULong);
-CPPYY_DECLARE_REFCONVERTER(LLong);
-CPPYY_DECLARE_REFCONVERTER(ULLong);
-CPPYY_DECLARE_REFCONVERTER(Float);
-CPPYY_DECLARE_REFCONVERTER(Double);
-CPPYY_DECLARE_REFCONVERTER(LDouble);
+CPPJIT_DECLARE_BASIC_CONVERTER(WChar);
+CPPJIT_DECLARE_BASIC_CONVERTER(Char16);
+CPPJIT_DECLARE_BASIC_CONVERTER(Char32);
+CPPJIT_DECLARE_BASIC_CONVERTER(Int8);
+CPPJIT_DECLARE_BASIC_CONVERTER(UInt8);
+CPPJIT_DECLARE_BASIC_CONVERTER(Short);
+CPPJIT_DECLARE_BASIC_CONVERTER(UShort);
+CPPJIT_DECLARE_BASIC_CONVERTER(Int);
+CPPJIT_DECLARE_BASIC_CONVERTER(ULong);
+CPPJIT_DECLARE_BASIC_CONVERTER2(UInt, ULong);
+CPPJIT_DECLARE_BASIC_CONVERTER(LLong);
+CPPJIT_DECLARE_BASIC_CONVERTER(ULLong);
+CPPJIT_DECLARE_BASIC_CONVERTER(Double);
+CPPJIT_DECLARE_BASIC_CONVERTER(Float);
+CPPJIT_DECLARE_BASIC_CONVERTER(LDouble);
+
+CPPJIT_DECLARE_REFCONVERTER(Bool);
+CPPJIT_DECLARE_REFCONVERTER(Char);
+CPPJIT_DECLARE_REFCONVERTER(WChar);
+CPPJIT_DECLARE_REFCONVERTER(Char16);
+CPPJIT_DECLARE_REFCONVERTER(Char32);
+CPPJIT_DECLARE_REFCONVERTER(SChar);
+CPPJIT_DECLARE_REFCONVERTER(UChar);
+CPPJIT_DECLARE_REFCONVERTER(Int8);
+CPPJIT_DECLARE_REFCONVERTER(UInt8);
+CPPJIT_DECLARE_REFCONVERTER(Short);
+CPPJIT_DECLARE_REFCONVERTER(UShort);
+CPPJIT_DECLARE_REFCONVERTER(UInt);
+CPPJIT_DECLARE_REFCONVERTER(Int);
+CPPJIT_DECLARE_REFCONVERTER(Long);
+CPPJIT_DECLARE_REFCONVERTER(ULong);
+CPPJIT_DECLARE_REFCONVERTER(LLong);
+CPPJIT_DECLARE_REFCONVERTER(ULLong);
+CPPJIT_DECLARE_REFCONVERTER(Float);
+CPPJIT_DECLARE_REFCONVERTER(Double);
+CPPJIT_DECLARE_REFCONVERTER(LDouble);
 
 class VoidConverter : public Converter {
 public:
@@ -216,25 +216,25 @@ class CString32Converter : public Converter {
 };
 
 // pointer/array conversions
-CPPYY_DECLARE_ARRAY_CONVERTER(Bool);
-CPPYY_DECLARE_ARRAY_CONVERTER(SChar);
-CPPYY_DECLARE_ARRAY_CONVERTER(UChar);
-CPPYY_DECLARE_ARRAY_CONVERTER(Byte);
-CPPYY_DECLARE_ARRAY_CONVERTER(Int8);
-CPPYY_DECLARE_ARRAY_CONVERTER(UInt8);
-CPPYY_DECLARE_ARRAY_CONVERTER(Short);
-CPPYY_DECLARE_ARRAY_CONVERTER(UShort);
-CPPYY_DECLARE_ARRAY_CONVERTER(Int);
-CPPYY_DECLARE_ARRAY_CONVERTER(UInt);
-CPPYY_DECLARE_ARRAY_CONVERTER(Long);
-CPPYY_DECLARE_ARRAY_CONVERTER(ULong);
-CPPYY_DECLARE_ARRAY_CONVERTER(LLong);
-CPPYY_DECLARE_ARRAY_CONVERTER(ULLong);
-CPPYY_DECLARE_ARRAY_CONVERTER(Float);
-CPPYY_DECLARE_ARRAY_CONVERTER(Double);
-CPPYY_DECLARE_ARRAY_CONVERTER(LDouble);
-CPPYY_DECLARE_ARRAY_CONVERTER(ComplexF);
-CPPYY_DECLARE_ARRAY_CONVERTER(ComplexD);
+CPPJIT_DECLARE_ARRAY_CONVERTER(Bool);
+CPPJIT_DECLARE_ARRAY_CONVERTER(SChar);
+CPPJIT_DECLARE_ARRAY_CONVERTER(UChar);
+CPPJIT_DECLARE_ARRAY_CONVERTER(Byte);
+CPPJIT_DECLARE_ARRAY_CONVERTER(Int8);
+CPPJIT_DECLARE_ARRAY_CONVERTER(UInt8);
+CPPJIT_DECLARE_ARRAY_CONVERTER(Short);
+CPPJIT_DECLARE_ARRAY_CONVERTER(UShort);
+CPPJIT_DECLARE_ARRAY_CONVERTER(Int);
+CPPJIT_DECLARE_ARRAY_CONVERTER(UInt);
+CPPJIT_DECLARE_ARRAY_CONVERTER(Long);
+CPPJIT_DECLARE_ARRAY_CONVERTER(ULong);
+CPPJIT_DECLARE_ARRAY_CONVERTER(LLong);
+CPPJIT_DECLARE_ARRAY_CONVERTER(ULLong);
+CPPJIT_DECLARE_ARRAY_CONVERTER(Float);
+CPPJIT_DECLARE_ARRAY_CONVERTER(Double);
+CPPJIT_DECLARE_ARRAY_CONVERTER(LDouble);
+CPPJIT_DECLARE_ARRAY_CONVERTER(ComplexF);
+CPPJIT_DECLARE_ARRAY_CONVERTER(ComplexD);
 
 class CStringArrayConverter : public SCharArrayConverter {
 public:
@@ -274,7 +274,7 @@ class InstanceConverter : public StrictInstancePtrConverter {
 
 class InstanceRefConverter : public Converter  {
 public:
-    InstanceRefConverter(Cppyy::TCppScope_t klass, bool isConst) :
+    InstanceRefConverter(cppjit::interop::TCppScope_t klass, bool isConst) :
         fClass(klass), fIsConst(isConst) {}
 
 public:
@@ -284,13 +284,13 @@ class InstanceRefConverter : public Converter  {
     std::string GetFailureMsg() override { return "[InstanceRefConverter]"; };
 
 protected:
-    Cppyy::TCppScope_t fClass;
+    cppjit::interop::TCppScope_t fClass;
     bool fIsConst;
 };
 
 class InstanceMoveConverter : public InstanceRefConverter  {
 public:
-    InstanceMoveConverter(Cppyy::TCppScope_t klass) : InstanceRefConverter(klass, true) {}
+    InstanceMoveConverter(cppjit::interop::TCppScope_t klass) : InstanceRefConverter(klass, true) {}
     bool SetArg(PyObject*, Parameter&, CallContext* = nullptr) override;
     std::string GetFailureMsg() override { return "[InstanceMoveConverter]"; };
 };
@@ -309,7 +309,7 @@ class InstancePtrPtrConverter : public InstancePtrConverter<false> {
 
 class InstanceArrayConverter : public InstancePtrConverter<false> {
 public:
-    InstanceArrayConverter(Cppyy::TCppScope_t klass, cdims_t dims, bool keepControl = false) :
+    InstanceArrayConverter(cppjit::interop::TCppScope_t klass, cdims_t dims, bool keepControl = false) :
             InstancePtrConverter<false>(klass, keepControl), fShape(dims) { }
     InstanceArrayConverter(const InstanceArrayConverter&) = delete;
     InstanceArrayConverter& operator=(const InstanceArrayConverter&) = delete;
@@ -371,10 +371,10 @@ class VoidPtrPtrConverter : public Converter {
     const std::string fFailureMsg;
 };
 
-CPPYY_DECLARE_BASIC_CONVERTER(PyObject);
+CPPJIT_DECLARE_BASIC_CONVERTER(PyObject);
 
 
-#define CPPYY_DECLARE_STRING_CONVERTER(name, strtype)                        \
+#define CPPJIT_DECLARE_STRING_CONVERTER(name, strtype)                        \
 class name##Converter : public InstanceConverter {                           \
 public:                                                                      \
     name##Converter(bool keepControl = true);                                \
@@ -389,9 +389,9 @@ protected:                                                                   \
     strtype fBuffer;                                                         \
 }
 
-CPPYY_DECLARE_STRING_CONVERTER(STLString, std::string);
-CPPYY_DECLARE_STRING_CONVERTER(STLWString, std::wstring);
-CPPYY_DECLARE_STRING_CONVERTER(STLStringView, std::string_view);
+CPPJIT_DECLARE_STRING_CONVERTER(STLString, std::string);
+CPPJIT_DECLARE_STRING_CONVERTER(STLWString, std::wstring);
+CPPJIT_DECLARE_STRING_CONVERTER(STLStringView, std::string_view);
 
 class STLStringMoveConverter : public STLStringConverter {
 public:
@@ -447,8 +447,8 @@ class StdFunctionConverter : public FunctionPointerConverter {
 // smart pointer converter
 class SmartPtrConverter : public Converter {
 public:
-    SmartPtrConverter(Cppyy::TCppScope_t smart,
-                      Cppyy::TCppScope_t underlying,
+    SmartPtrConverter(cppjit::interop::TCppScope_t smart,
+                      cppjit::interop::TCppScope_t underlying,
                       bool keepControl = false,
                       bool isRef = false)
         : fSmartPtrType(smart), fUnderlyingType(underlying),
@@ -464,8 +464,8 @@ class SmartPtrConverter : public Converter {
 protected:
     virtual bool GetAddressSpecialCase(PyObject*, void*&) { return false; }
 
-    Cppyy::TCppScope_t  fSmartPtrType;
-    Cppyy::TCppScope_t  fUnderlyingType;
+    cppjit::interop::TCppScope_t  fSmartPtrType;
+    cppjit::interop::TCppScope_t  fUnderlyingType;
     bool                fKeepControl;
     bool                fIsRef;
 };
@@ -474,7 +474,7 @@ class SmartPtrConverter : public Converter {
 // initializer lists
 class InitializerListConverter : public InstanceConverter {
 public:
-    InitializerListConverter(Cppyy::TCppScope_t klass, std::string const& value_type);
+    InitializerListConverter(cppjit::interop::TCppScope_t klass, std::string const& value_type);
     InitializerListConverter(const InitializerListConverter&) = delete;
     InitializerListConverter& operator=(const InitializerListConverter&) = delete;
     virtual ~InitializerListConverter();
@@ -491,12 +491,12 @@ class InitializerListConverter : public InstanceConverter {
     void*             fBuffer = nullptr;
     std::vector<Converter*> fConverters;
     std::string       fValueTypeName;
-    Cppyy::TCppScope_t fValueType;
+    cppjit::interop::TCppScope_t fValueType;
     size_t            fValueSize;
 };
 
 } // unnamed namespace
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_DECLARECONVERTERS_H
+#endif // !CPYRT_DECLARECONVERTERS_H
diff --git a/src/cpyrt/DeclareExecutors.h b/src/cpyrt/DeclareExecutors.h
new file mode 100644
index 0000000..8c85dab
--- /dev/null
+++ b/src/cpyrt/DeclareExecutors.h
@@ -0,0 +1,204 @@
+#ifndef CPYRT_DECLAREEXECUTORS_H
+#define CPYRT_DECLAREEXECUTORS_H
+
+#include "Python.h"
+#include "cppjit_interop.h"
+
+// Bindings
+#include "Executors.h"
+#include "CallContext.h"
+#include "Dimensions.h"
+
+// Standard
+#include <cstddef>
+
+
+namespace cppjit::cpyrt {
+
+namespace {
+
+#define CPPJIT_DECL_EXEC(name)                                                \
+class name##Executor : public Executor {                                     \
+public:                                                                      \
+    PyObject* Execute(                                                       \
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;    \
+}
+
+// executors for built-ins
+CPPJIT_DECL_EXEC(Bool);
+CPPJIT_DECL_EXEC(BoolConstRef);
+CPPJIT_DECL_EXEC(Char);
+CPPJIT_DECL_EXEC(CharConstRef);
+CPPJIT_DECL_EXEC(UChar);
+CPPJIT_DECL_EXEC(UCharConstRef);
+CPPJIT_DECL_EXEC(WChar);
+CPPJIT_DECL_EXEC(Char16);
+CPPJIT_DECL_EXEC(Char32);
+CPPJIT_DECL_EXEC(Int8);
+CPPJIT_DECL_EXEC(Int8ConstRef);
+CPPJIT_DECL_EXEC(UInt8);
+CPPJIT_DECL_EXEC(UInt8ConstRef);
+CPPJIT_DECL_EXEC(Short);
+CPPJIT_DECL_EXEC(Int);
+CPPJIT_DECL_EXEC(Long);
+CPPJIT_DECL_EXEC(ULong);
+CPPJIT_DECL_EXEC(LongLong);
+CPPJIT_DECL_EXEC(ULongLong);
+CPPJIT_DECL_EXEC(Float);
+CPPJIT_DECL_EXEC(Double);
+CPPJIT_DECL_EXEC(LongDouble);
+CPPJIT_DECL_EXEC(Void);
+CPPJIT_DECL_EXEC(CString);
+CPPJIT_DECL_EXEC(CStringRef);
+CPPJIT_DECL_EXEC(WCString);
+CPPJIT_DECL_EXEC(CString16);
+CPPJIT_DECL_EXEC(CString32);
+
+// pointer/array executors
+#define CPPJIT_ARRAY_DECL_EXEC(name)                                          \
+class name##ArrayExecutor : public Executor {                                \
+    dims_t fShape;                                                           \
+public:                                                                      \
+    name##ArrayExecutor(dims_t dims) : fShape(dims) {}                       \
+    PyObject* Execute(                                                       \
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;    \
+    bool HasState() override { return true; }                                \
+}
+CPPJIT_ARRAY_DECL_EXEC(Void);
+CPPJIT_ARRAY_DECL_EXEC(Bool);
+CPPJIT_ARRAY_DECL_EXEC(SChar);
+CPPJIT_ARRAY_DECL_EXEC(UChar);
+CPPJIT_ARRAY_DECL_EXEC(Byte);
+CPPJIT_ARRAY_DECL_EXEC(Int8);
+CPPJIT_ARRAY_DECL_EXEC(UInt8);
+CPPJIT_ARRAY_DECL_EXEC(Short);
+CPPJIT_ARRAY_DECL_EXEC(UShort);
+CPPJIT_ARRAY_DECL_EXEC(Int);
+CPPJIT_ARRAY_DECL_EXEC(UInt);
+CPPJIT_ARRAY_DECL_EXEC(Long);
+CPPJIT_ARRAY_DECL_EXEC(ULong);
+CPPJIT_ARRAY_DECL_EXEC(LLong);
+CPPJIT_ARRAY_DECL_EXEC(ULLong);
+CPPJIT_ARRAY_DECL_EXEC(Float);
+CPPJIT_ARRAY_DECL_EXEC(Double);
+CPPJIT_ARRAY_DECL_EXEC(LDouble);
+CPPJIT_ARRAY_DECL_EXEC(ComplexF);
+CPPJIT_ARRAY_DECL_EXEC(ComplexD);
+CPPJIT_ARRAY_DECL_EXEC(ComplexI);
+CPPJIT_ARRAY_DECL_EXEC(ComplexL);
+
+// special cases
+CPPJIT_DECL_EXEC(ComplexD);
+CPPJIT_DECL_EXEC(STLString);
+CPPJIT_DECL_EXEC(STLWString);
+
+class InstancePtrExecutor : public Executor {
+public:
+    InstancePtrExecutor(cppjit::interop::TCppScope_t klass) : fClass(klass) {}
+    PyObject* Execute(
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;
+    bool HasState() override { return true; }
+
+protected:
+    cppjit::interop::TCppScope_t fClass;
+};
+
+class InstanceExecutor : public Executor {
+public:
+    InstanceExecutor(cppjit::interop::TCppScope_t klass);
+    PyObject* Execute(
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;
+    bool HasState() override { return true; }
+
+protected:
+    cppjit::interop::TCppScope_t fClass;
+    uint32_t           fFlags;
+};
+
+class IteratorExecutor : public InstanceExecutor {
+public:
+    IteratorExecutor(cppjit::interop::TCppScope_t klass);
+};
+
+CPPJIT_DECL_EXEC(Constructor);
+CPPJIT_DECL_EXEC(PyObject);
+
+#define CPPJIT_DECL_REFEXEC(name)                                             \
+class name##RefExecutor : public RefExecutor {                               \
+public:                                                                      \
+    PyObject* Execute(                                                       \
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;    \
+}
+
+CPPJIT_DECL_REFEXEC(Bool);
+CPPJIT_DECL_REFEXEC(Char);
+CPPJIT_DECL_REFEXEC(UChar);
+CPPJIT_DECL_REFEXEC(Int8);
+CPPJIT_DECL_REFEXEC(UInt8);
+CPPJIT_DECL_REFEXEC(Short);
+CPPJIT_DECL_REFEXEC(UShort);
+CPPJIT_DECL_REFEXEC(Int);
+CPPJIT_DECL_REFEXEC(UInt);
+CPPJIT_DECL_REFEXEC(Long);
+CPPJIT_DECL_REFEXEC(ULong);
+CPPJIT_DECL_REFEXEC(LongLong);
+CPPJIT_DECL_REFEXEC(ULongLong);
+CPPJIT_DECL_REFEXEC(Float);
+CPPJIT_DECL_REFEXEC(Double);
+CPPJIT_DECL_REFEXEC(LongDouble);
+CPPJIT_DECL_REFEXEC(ComplexD);
+CPPJIT_DECL_REFEXEC(STLString);
+
+// special cases
+class InstanceRefExecutor : public RefExecutor {
+public:
+    InstanceRefExecutor(cppjit::interop::TCppScope_t klass) : fClass(klass) {}
+    PyObject* Execute(
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;
+
+protected:
+    cppjit::interop::TCppScope_t fClass;
+};
+
+class InstancePtrPtrExecutor : public InstanceRefExecutor {
+public:
+    using InstanceRefExecutor::InstanceRefExecutor;
+    PyObject* Execute(
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;
+};
+
+class InstancePtrRefExecutor : public InstanceRefExecutor {
+public:
+    using InstanceRefExecutor::InstanceRefExecutor;
+    PyObject* Execute(
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;
+};
+
+class InstanceArrayExecutor : public InstancePtrExecutor {
+public:
+    InstanceArrayExecutor(cppjit::interop::TCppScope_t klass, dim_t array_size)
+        : InstancePtrExecutor(klass), fSize(array_size) {}
+    PyObject* Execute(
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;
+
+protected:
+    dim_t fSize;
+};
+
+class FunctionPointerExecutor : public Executor {
+public:
+    FunctionPointerExecutor(const std::string& ret, const std::string& sig) :
+        fRetType(ret), fSignature(sig) {}
+    PyObject* Execute(
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) override;
+
+protected:
+    std::string fRetType;
+    std::string fSignature;
+};
+
+} // unnamed namespace
+
+} // namespace cppjit::cpyrt
+
+#endif // !CPYRT_DECLAREEXECUTORS_H
diff --git a/src/CPyCppyy/src/Dimensions.h b/src/cpyrt/Dimensions.h
similarity index 90%
rename from src/CPyCppyy/src/Dimensions.h
rename to src/cpyrt/Dimensions.h
index 1f29ae0..eaa0343 100644
--- a/src/CPyCppyy/src/Dimensions.h
+++ b/src/cpyrt/Dimensions.h
@@ -1,22 +1,22 @@
-#ifndef CPYCPPYY_DIMENSIONS_H
-#define CPYCPPYY_DIMENSIONS_H
+#ifndef CPYRT_DIMENSIONS_H
+#define CPYRT_DIMENSIONS_H
 
 #include "Python.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 
 // Bindings
-#include "CPyCppyy/CommonDefs.h"
+#include "cpyrt/CommonDefs.h"
 
 // Standard
 #include <algorithm>
 #include <initializer_list>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 static const dim_t UNKNOWN_SIZE = (dim_t)-1;
 
-class CPYCPPYY_CLASS_EXPORT Dimensions {
+class CPYRT_CLASS_EXPORT Dimensions {
     dim_t* fDims;
 
 public:
@@ -85,6 +85,6 @@ class CPYCPPYY_CLASS_EXPORT Dimensions {
 typedef Dimensions dims_t;
 typedef const dims_t& cdims_t;
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_DIMENSIONS_H
+#endif // !CPYRT_DIMENSIONS_H
diff --git a/src/CPyCppyy/src/DispatchPtr.cxx b/src/cpyrt/DispatchPtr.cxx
similarity index 80%
rename from src/CPyCppyy/src/DispatchPtr.cxx
rename to src/cpyrt/DispatchPtr.cxx
index da1682d..bca5e55 100644
--- a/src/CPyCppyy/src/DispatchPtr.cxx
+++ b/src/cpyrt/DispatchPtr.cxx
@@ -1,14 +1,14 @@
 // Bindings
-#include "CPyCppyy.h"
-#define CPYCPPYY_INTERNAL 1
-#include "CPyCppyy/DispatchPtr.h"
-#undef CPYCPPYY_INTERNAL
+#include "cpyrt.h"
+#define CPYRT_INTERNAL 1
+#include "cpyrt/DispatchPtr.h"
+#undef CPYRT_INTERNAL
 #include "CPPInstance.h"
 #include "CPPScope.h"
 
 
 //-----------------------------------------------------------------------------
-PyObject* CPyCppyy::DispatchPtr::Get(bool borrowed) const
+PyObject* cppjit::cpyrt::DispatchPtr::Get(bool borrowed) const
 {
     PythonGILRAII python_gil_raii;
     if (fPyHardRef) {
@@ -16,7 +16,7 @@ PyObject* CPyCppyy::DispatchPtr::Get(bool borrowed) const
         return fPyHardRef;
     }
     if (fPyWeakRef) {
-        PyObject* disp = CPyCppyy_GetWeakRef(fPyWeakRef);
+        PyObject* disp = cpyrt_GetWeakRef(fPyWeakRef);
         if (disp) {               // dispatcher object disappeared?
             if (borrowed) Py_DECREF(disp);
             return disp;
@@ -26,7 +26,7 @@ PyObject* CPyCppyy::DispatchPtr::Get(bool borrowed) const
 }
 
 //-----------------------------------------------------------------------------
-CPyCppyy::DispatchPtr::DispatchPtr(PyObject* pyobj, bool strong) : fPyHardRef(nullptr)
+cppjit::cpyrt::DispatchPtr::DispatchPtr(PyObject* pyobj, bool strong) : fPyHardRef(nullptr)
 {
     PythonGILRAII python_gil_raii;
     if (strong) {
@@ -41,7 +41,7 @@ CPyCppyy::DispatchPtr::DispatchPtr(PyObject* pyobj, bool strong) : fPyHardRef(nu
 }
 
 //-----------------------------------------------------------------------------
-CPyCppyy::DispatchPtr::DispatchPtr(const DispatchPtr& other, void* cppinst) : fPyWeakRef(nullptr)
+cppjit::cpyrt::DispatchPtr::DispatchPtr(const DispatchPtr& other, void* cppinst) : fPyWeakRef(nullptr)
 {
     PythonGILRAII python_gil_raii;
     PyObject* pyobj = other.Get(false /* not borrowed */);
@@ -51,14 +51,14 @@ CPyCppyy::DispatchPtr::DispatchPtr(const DispatchPtr& other, void* cppinst) : fP
 }
 
 //-----------------------------------------------------------------------------
-CPyCppyy::DispatchPtr::~DispatchPtr() {
+cppjit::cpyrt::DispatchPtr::~DispatchPtr() {
 // if we're holding a hard reference, or holding weak reference while being part
 // of a dispatcher intermediate, then this delete is from the C++ side, and Python
 // is "notified" by nulling out the reference and an exception will be raised on
 // continued access
     PythonGILRAII python_gil_raii;
     if (fPyWeakRef) {
-        PyObject* pyobj = CPyCppyy_GetWeakRef(fPyWeakRef);
+        PyObject* pyobj = cpyrt_GetWeakRef(fPyWeakRef);
         if (pyobj && ((CPPScope*)Py_TYPE(pyobj))->fFlags & CPPScope::kIsPython)
             ((CPPInstance*)pyobj)->GetObjectRaw() = nullptr;
         Py_XDECREF(pyobj);
@@ -70,7 +70,7 @@ CPyCppyy::DispatchPtr::~DispatchPtr() {
 }
 
 //-----------------------------------------------------------------------------
-CPyCppyy::DispatchPtr& CPyCppyy::DispatchPtr::assign(const DispatchPtr& other, void* cppinst)
+cppjit::cpyrt::DispatchPtr& cppjit::cpyrt::DispatchPtr::assign(const DispatchPtr& other, void* cppinst)
 {
     PythonGILRAII python_gil_raii;
     if (this != &other) {
@@ -85,7 +85,7 @@ CPyCppyy::DispatchPtr& CPyCppyy::DispatchPtr::assign(const DispatchPtr& other, v
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::DispatchPtr::PythonOwns()
+void cppjit::cpyrt::DispatchPtr::PythonOwns()
 {
     PythonGILRAII python_gil_raii;
 // Python maintains the hardref, so only allowed a weakref here
@@ -96,12 +96,12 @@ void CPyCppyy::DispatchPtr::PythonOwns()
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::DispatchPtr::CppOwns()
+void cppjit::cpyrt::DispatchPtr::CppOwns()
 {
     PythonGILRAII python_gil_raii;
 // C++ maintains the hardref, keeping the PyObject alive w/o outstanding ref
     if (fPyWeakRef) {
-        fPyHardRef = CPyCppyy_GetWeakRef(fPyWeakRef);
+        fPyHardRef = cpyrt_GetWeakRef(fPyWeakRef);
         Py_DECREF(fPyWeakRef); fPyWeakRef = nullptr;
     }
 }
diff --git a/src/CPyCppyy/include/CPyCppyy/DispatchPtr.h b/src/cpyrt/DispatchPtr.h
similarity index 93%
rename from src/CPyCppyy/include/CPyCppyy/DispatchPtr.h
rename to src/cpyrt/DispatchPtr.h
index 1cef6fa..795a084 100644
--- a/src/CPyCppyy/include/CPyCppyy/DispatchPtr.h
+++ b/src/cpyrt/DispatchPtr.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_DISPATCHPTR_H
-#define CPYCPPYY_DISPATCHPTR_H
+#ifndef CPYRT_DISPATCHPTR_H
+#define CPYRT_DISPATCHPTR_H
 
 //////////////////////////////////////////////////////////////////////////////
 //                                                                          //
@@ -15,10 +15,10 @@
 //////////////////////////////////////////////////////////////////////////////
 
 // Bindings
-#include "CPyCppyy/CommonDefs.h"
+#include "cpyrt/CommonDefs.h"
 #include <Python.h>
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 class PythonGILRAII {
   PyGILState_STATE state;
 
@@ -27,7 +27,7 @@ class PythonGILRAII {
   ~PythonGILRAII() { PyGILState_Release(state); }
 };
 
-class CPYCPPYY_CLASS_EXTERN DispatchPtr {
+class CPYRT_CLASS_EXTERN DispatchPtr {
 public:
 // Default constructor: only ever created from C++, as by definition, creation
 // from the Python side makes the relevant Python instance available. Calls to
@@ -78,6 +78,6 @@ class CPYCPPYY_CLASS_EXTERN DispatchPtr {
     PyObject* fPyWeakRef;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_DISPATCHPTR_H
+#endif // !CPYRT_DISPATCHPTR_H
diff --git a/src/CPyCppyy/src/Dispatcher.cxx b/src/cpyrt/Dispatcher.cxx
similarity index 76%
rename from src/CPyCppyy/src/Dispatcher.cxx
rename to src/cpyrt/Dispatcher.cxx
index 12b8ee4..41c979b 100644
--- a/src/CPyCppyy/src/Dispatcher.cxx
+++ b/src/cpyrt/Dispatcher.cxx
@@ -1,8 +1,8 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "Dispatcher.h"
 #include "CPPScope.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "PyStrings.h"
 #include "ProxyWrappers.h"
 #include "TypeManip.h"
@@ -14,25 +14,25 @@
 
 
 //----------------------------------------------------------------------------
-static inline void InjectMethod(Cppyy::TCppMethod_t method, const std::string& mtCppName, std::ostringstream& code)
+static inline void InjectMethod(cppjit::interop::TCppMethod_t method, const std::string& mtCppName, std::ostringstream& code)
 {
 // inject implementation for an overridden method
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
 
 // method declaration
-    std::string retType = Cppyy::GetMethodReturnTypeAsString(method);
+    std::string retType = cppjit::interop::GetMethodReturnTypeAsString(method);
     code << "  " << retType << " " << mtCppName << "(";
 
 // build out the signature with predictable formal names
-    Cppyy::TCppIndex_t nArgs = Cppyy::GetMethodNumArgs(method);
+    cppjit::interop::TCppIndex_t nArgs = cppjit::interop::GetMethodNumArgs(method);
     std::vector<std::string> argtypes; argtypes.reserve(nArgs);
-    for (Cppyy::TCppIndex_t i = 0; i < nArgs; ++i) {
-        argtypes.push_back(Cppyy::GetMethodArgCanonTypeAsString(method, i));
+    for (cppjit::interop::TCppIndex_t i = 0; i < nArgs; ++i) {
+        argtypes.push_back(cppjit::interop::GetMethodArgCanonTypeAsString(method, i));
         if (i != 0) code << ", ";
         code << argtypes.back() << " arg" << i;
     }
     code << ") ";
-    if (Cppyy::IsConstMethod(method)) code << "const ";
+    if (cppjit::interop::IsConstMethod(method)) code << "const ";
     code << "{\n";
 
 // on destruction, the Python object may go first, in which case provide a diagnostic
@@ -40,7 +40,7 @@ static inline void InjectMethod(Cppyy::TCppMethod_t method, const std::string& m
 // program shutdown); note that this means that the actual result will be the default
 // and the caller may need to act on that, but that's still an improvement over a
 // possible crash
-    code << "    CPyCppyy::PythonGILRAII python_gil_raii;\n" // acquire GIL
+    code << "    cppjit::cpyrt::PythonGILRAII python_gil_raii;\n" // acquire GIL
             "    PyObject* iself = (PyObject*)_internal_self;\n"
             "    if (!iself || iself == Py_None) {\n"
             "      PyErr_Warn(PyExc_RuntimeWarning, (char*)\"Call attempted on "
@@ -48,7 +48,7 @@ static inline void InjectMethod(Cppyy::TCppMethod_t method, const std::string& m
             "      return";
     if (retType != "void") {
         if (retType.back() != '*')
-            code << " (" << CPyCppyy::TypeManip::remove_const(retType) << "){}";
+            code << " (" << cppjit::cpyrt::TypeManip::remove_const(retType) << "){}";
         else
             code << " nullptr";
     }
@@ -62,7 +62,7 @@ static inline void InjectMethod(Cppyy::TCppMethod_t method, const std::string& m
 // perform actual method call
     code << "    PyObject* mtPyName = PyUnicode_FromString(\"" << mtCppName << "\");\n"
             "    PyObject* pyresult = PyObject_CallMethodObjArgs(iself, mtPyName";
-    for (Cppyy::TCppIndex_t i = 0; i < nArgs; ++i)
+    for (cppjit::interop::TCppIndex_t i = 0; i < nArgs; ++i)
         code << ", pyargs[" << i << "]";
     code << ", NULL);\n    Py_DECREF(mtPyName);\n    Py_DECREF(iself);\n";
 
@@ -73,17 +73,17 @@ static inline void InjectMethod(Cppyy::TCppMethod_t method, const std::string& m
 //----------------------------------------------------------------------------
 namespace {
     struct BaseInfo {
-        BaseInfo(Cppyy::TCppScope_t t, std::string&& bn, std::string&& bns) :
+        BaseInfo(cppjit::interop::TCppScope_t t, std::string&& bn, std::string&& bns) :
             btype(t), bname(bn), bname_scoped(bns) {}
-        Cppyy::TCppScope_t btype;
+        cppjit::interop::TCppScope_t btype;
         std::string bname;
         std::string bname_scoped;
     };
 
     typedef std::vector<BaseInfo> BaseInfos_t;
-    typedef std::vector<Cppyy::TCppMethod_t> Ctors_t;
+    typedef std::vector<cppjit::interop::TCppMethod_t> Ctors_t;
     typedef std::vector<Ctors_t> AllCtors_t;
-    typedef std::vector<std::pair<Cppyy::TCppMethod_t, size_t>> CtorInfos_t;
+    typedef std::vector<std::pair<cppjit::interop::TCppMethod_t, size_t>> CtorInfos_t;
 } // unnamed namespace
 
 static void build_constructors(
@@ -92,8 +92,8 @@ static void build_constructors(
 {
     if (idx < ctors.size()) {
         for (const auto& method : ctors[idx]) {
-             size_t argsmin = (size_t)Cppyy::GetMethodReqArgs(method);
-             size_t argsmax = (size_t)Cppyy::GetMethodNumArgs(method);
+             size_t argsmin = (size_t)cppjit::interop::GetMethodReqArgs(method);
+             size_t argsmax = (size_t)cppjit::interop::GetMethodNumArgs(method);
              for (size_t i = argsmin; i <= argsmax; ++i) {
                  CtorInfos_t methods1{methods};
                  methods1.emplace_back(method, i);
@@ -112,11 +112,11 @@ static void build_constructors(
             size_t nArgs = cinfo.second;
             arg_tots.push_back(i == 0 ? nArgs : nArgs+arg_tots.back());
 
-            if (i != 0) code << "__cppyy_internal::Sep*";
+            if (i != 0) code << "__cppjit_internal::Sep*";
             size_t offset = (i != 0 ? arg_tots[i-1] : 0);
             for (size_t j = 0; j < nArgs; ++j) {
                 if (i != 0 || j != 0) code << ", ";
-                code << Cppyy::GetMethodArgCanonTypeAsString(cinfo.first, j) << " a" << (j+offset);
+                code << cppjit::interop::GetMethodArgCanonTypeAsString(cinfo.first, j) << " a" << (j+offset);
             }
         }
         code << ") : ";
@@ -128,8 +128,8 @@ static void build_constructors(
             size_t first = (i != 0 ? arg_tots[i-1] : 0);
             for (size_t j = first; j < arg_tots[i]; ++j) {
                 if (j != first) code << ", ";
-                bool isRValue = CPyCppyy::TypeManip::compound(\
-                    Cppyy::GetMethodArgCanonTypeAsString(methods[i].first, j-first)) == "&&";
+                bool isRValue = cppjit::cpyrt::TypeManip::compound(\
+                    cppjit::interop::GetMethodArgCanonTypeAsString(methods[i].first, j-first)) == "&&";
                 if (isRValue) code << "std::move(";
                 code << "a" << j;
                 if (isRValue) code << ")";
@@ -142,7 +142,7 @@ static void build_constructors(
 
 namespace {
 
-using namespace Cppyy;
+using namespace cppjit::interop;
 
 static inline
 std::vector<TCppMethod_t> FindBaseMethod(TCppScope_t tbase, const std::string mtCppName)
@@ -152,7 +152,7 @@ std::vector<TCppMethod_t> FindBaseMethod(TCppScope_t tbase, const std::string mt
     result = GetMethodsFromName(tbase, mtCppName);
     if (result.empty()) {
         for (TCppIndex_t ibase = 0; ibase < GetNumBases(tbase); ++ibase) {
-            TCppScope_t b = Cppyy::GetBaseScope(tbase, ibase);
+            TCppScope_t b = cppjit::interop::GetBaseScope(tbase, ibase);
             result = FindBaseMethod(b, mtCppName);
             if (!result.empty())
                 break;
@@ -163,7 +163,7 @@ std::vector<TCppMethod_t> FindBaseMethod(TCppScope_t tbase, const std::string mt
 
 } // unnamed namespace
 
-bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct, std::ostringstream& err)
+bool cppjit::cpyrt::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct, std::ostringstream& err)
 {
 // Scan all methods in dct and where it overloads base methods in klass, create
 // dispatchers on the C++ side. Then interject the dispatcher class.
@@ -185,26 +185,26 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
         if (!CPPScope_Check(PyTuple_GET_ITEM(bases, ibase)))
             continue;
 
-        Cppyy::TCppScope_t basetype = ((CPPScope*)PyTuple_GET_ITEM(bases, ibase))->fCppType;
+        cppjit::interop::TCppScope_t basetype = ((CPPScope*)PyTuple_GET_ITEM(bases, ibase))->fCppType;
 
         if (!basetype) {
             err << "base class is incomplete";
             break;
         }
 
-        if (Cppyy::IsNamespace(basetype)) {
-            err << Cppyy::GetScopedFinalName(basetype) << " is a namespace";
+        if (cppjit::interop::IsNamespace(basetype)) {
+            err << cppjit::interop::GetScopedFinalName(basetype) << " is a namespace";
             break;
         }
 
-        if (!Cppyy::HasVirtualDestructor(basetype)) {
-            const std::string& bname = Cppyy::GetScopedFinalName(basetype);
+        if (!cppjit::interop::HasVirtualDestructor(basetype)) {
+            const std::string& bname = cppjit::interop::GetScopedFinalName(basetype);
             if (PyErr_WarnEx(PyExc_RuntimeWarning, (char*)("class \""+bname+"\" has no virtual destructor").c_str(), 1) < 0)
                 return false;
         }
 
         base_infos.emplace_back(
-            basetype, TypeManip::template_base(Cppyy::GetFinalName(basetype)), Cppyy::GetScopedFinalName(basetype));
+            basetype, TypeManip::template_base(cppjit::interop::GetFinalName(basetype)), cppjit::interop::GetScopedFinalName(basetype));
     }
 
 // TODO: check deep hierarchy for multiple inheritance
@@ -221,7 +221,7 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
     std::ostringstream code;
 
 // start class declaration
-    code << "namespace __cppyy_internal {\n"
+    code << "namespace __cppjit_internal {\n"
          << "class " << derivedName << " : ";
     for (BaseInfos_t::size_type ibase = 0; ibase < base_infos.size(); ++ibase) {
         if (ibase != 0) code << ", ";
@@ -229,7 +229,7 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
     }
     code << " {\n";
     if (!isDeepHierarchy)
-        code << "protected:\n  CPyCppyy::DispatchPtr _internal_self;\n";
+        code << "protected:\n  cppjit::cpyrt::DispatchPtr _internal_self;\n";
     code << "public:\n";
 
 // add a virtual destructor for good measure, which is allowed to be "overridden" by
@@ -238,7 +238,7 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
 // object goes before the C++ one, only __del__ is called)
     if (PyMapping_HasKeyString(dct, (char*)"__destruct__")) {
         code << "  virtual ~" << derivedName << "() {\n"
-                "    CPyCppyy::PythonGILRAII python_gil_raii;\n"
+                "    cppjit::cpyrt::PythonGILRAII python_gil_raii;\n"
                 "    PyObject* iself = (PyObject*)_internal_self;\n"
                 "    if (!iself || iself == Py_None)\n"
                 "      return;\n"      // safe, as destructor always returns void
@@ -278,18 +278,18 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
     for (BaseInfos_t::size_type ibase = 0; ibase < base_infos.size(); ++ibase) {
         const auto& binfo = base_infos[ibase];
 
-        std::vector<Cppyy::TCppMethod_t> methods;
-        Cppyy::GetClassMethods(binfo.btype, methods);
+        std::vector<cppjit::interop::TCppMethod_t> methods;
+        cppjit::interop::GetClassMethods(binfo.btype, methods);
         bool cctor_found = false, default_found = false, any_ctor_found = false;
         for (auto &method : methods) {
-            if (Cppyy::IsConstructor(method)) {
+            if (cppjit::interop::IsConstructor(method)) {
                 any_ctor_found = true;
-                if ((Cppyy::IsPublicMethod(method) || Cppyy::IsProtectedMethod(method)) &&
-                    !Cppyy::IsDeletedMethod(method)) {
-                    Cppyy::TCppIndex_t nreq = Cppyy::GetMethodReqArgs(method);
+                if ((cppjit::interop::IsPublicMethod(method) || cppjit::interop::IsProtectedMethod(method)) &&
+                    !cppjit::interop::IsDeletedMethod(method)) {
+                    cppjit::interop::TCppIndex_t nreq = cppjit::interop::GetMethodReqArgs(method);
                     if (nreq == 0) default_found = true;
                     else if (!cctor_found && nreq == 1) {
-                        const std::string& argtype = Cppyy::GetMethodArgCanonTypeAsString(method, 0);
+                        const std::string& argtype = cppjit::interop::GetMethodArgCanonTypeAsString(method, 0);
                         if (TypeManip::compound(argtype) == "&" && TypeManip::clean_type(argtype, false) == binfo.bname_scoped)
                             cctor_found = true;
                     }
@@ -298,8 +298,8 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
                 continue;
             }
 
-            std::string mtCppName = Cppyy::GetName(Cppyy::TCppScope_t(method.data));
-            PyObject* key = CPyCppyy_PyText_FromString(mtCppName.c_str());
+            std::string mtCppName = cppjit::interop::GetName(cppjit::interop::TCppScope_t(method.data));
+            PyObject* key = cpyrt_PyText_FromString(mtCppName.c_str());
             int contains = PyDict_Contains(dct, key);
             if (contains == -1) PyErr_Clear();
             if (contains != 1) {
@@ -307,21 +307,21 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
 
             // if the method is protected, we expose it through re-declaration and forwarding (using
             // does not work here b/c there may be private overloads)
-                if (Cppyy::IsProtectedMethod(method)) {
+                if (cppjit::interop::IsProtectedMethod(method)) {
                     protected_names.insert(mtCppName);
 
-                    code << "  " << Cppyy::GetMethodReturnTypeAsString(method) << " " << mtCppName << "(";
-                    Cppyy::TCppIndex_t nArgs = Cppyy::GetMethodNumArgs(method);
-                    for (Cppyy::TCppIndex_t i = 0; i < nArgs; ++i) {
+                    code << "  " << cppjit::interop::GetMethodReturnTypeAsString(method) << " " << mtCppName << "(";
+                    cppjit::interop::TCppIndex_t nArgs = cppjit::interop::GetMethodNumArgs(method);
+                    for (cppjit::interop::TCppIndex_t i = 0; i < nArgs; ++i) {
                         if (i != 0) code << ", ";
-                        code << Cppyy::GetMethodArgCanonTypeAsString(method, i) << " arg" << i;
+                        code << cppjit::interop::GetMethodArgCanonTypeAsString(method, i) << " arg" << i;
                     }
                     code << ") ";
-                    if (Cppyy::IsConstMethod(method)) code << "const ";
+                    if (cppjit::interop::IsConstMethod(method)) code << "const ";
                     code << "{\n    return " << binfo.bname << "::" << mtCppName << "(";
-                    for (Cppyy::TCppIndex_t i = 0; i < nArgs; ++i) {
+                    for (cppjit::interop::TCppIndex_t i = 0; i < nArgs; ++i) {
                         if (i != 0) code << ", ";
-                        if (Cppyy::IsRValueReferenceType(Cppyy::GetMethodArgType(method, i)))
+                        if (cppjit::interop::IsRValueReferenceType(cppjit::interop::GetMethodArgType(method, i)))
                             code << "std::move(arg" << i << ")";
                         else
                             code << "arg" << i;
@@ -341,10 +341,10 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
 
     // support for templated ctors in single inheritance (TODO: also multi possible?)
         if (base_infos.size() == 1) {
-                std::vector<Cppyy::TCppMethod_t> templ_methods;
-                Cppyy::GetTemplatedMethods(binfo.btype, templ_methods);
+                std::vector<cppjit::interop::TCppMethod_t> templ_methods;
+                cppjit::interop::GetTemplatedMethods(binfo.btype, templ_methods);
                 for (auto &method : templ_methods) {
-                if (Cppyy::IsConstructor(method)) {
+                if (cppjit::interop::IsConstructor(method)) {
                     any_ctor_found = true;
                     has_tmpl_ctors += 1;
                     break;        // one suffices to map as argument packs are used
@@ -361,16 +361,16 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
 // try to locate left-overs in base classes
     for (const auto& binfo : base_infos) {
         if (PyDict_Size(clbs)) {
-            size_t nbases = Cppyy::GetNumBases(binfo.btype);
+            size_t nbases = cppjit::interop::GetNumBases(binfo.btype);
             for (size_t ibase = 0; ibase < nbases; ++ibase) {
-                Cppyy::TCppScope_t tbase =
-                    (Cppyy::TCppScope_t) Cppyy::GetBaseScope(binfo.btype, ibase);
+                cppjit::interop::TCppScope_t tbase =
+                    (cppjit::interop::TCppScope_t) cppjit::interop::GetBaseScope(binfo.btype, ibase);
 
                 PyObject* keys = PyDict_Keys(clbs);
                 for (Py_ssize_t i = 0; i < PyList_GET_SIZE(keys); ++i) {
                 // TODO: should probably invert this looping; but that makes handling overloads clunky
                     PyObject* key = PyList_GET_ITEM(keys, i);
-                    std::string mtCppName = CPyCppyy_PyText_AsString(key);
+                    std::string mtCppName = cpyrt_PyText_AsString(key);
                     const auto& methods = FindBaseMethod(tbase, mtCppName);
                     for (auto method : methods)
                         InjectMethod(method, mtCppName, code);
@@ -415,13 +415,13 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
 // pull in data members that are protected
     bool setPublic = false;
     for (const auto& binfo : base_infos) {
-        std::vector<Cppyy::TCppScope_t> datamems;
-        Cppyy::GetDatamembers(binfo.btype, datamems);
+        std::vector<cppjit::interop::TCppScope_t> datamems;
+        cppjit::interop::GetDatamembers(binfo.btype, datamems);
         for (auto data : datamems) {
-            if (Cppyy::IsProtectedData(data)) {
-                const std::string dm_name = Cppyy::GetFinalName(data);
+            if (cppjit::interop::IsProtectedData(data)) {
+                const std::string dm_name = cppjit::interop::GetFinalName(data);
                 if (dm_name != "_internal_self") {
-                    const std::string& dname = Cppyy::GetFinalName(data);
+                    const std::string& dname = cppjit::interop::GetFinalName(data);
                     protected_names.insert(dname);
                     if (!setPublic) {
                         code << "public:\n";
@@ -438,7 +438,7 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
     code << "public:\n  static void _init_dispatchptr(" << derivedName << "* inst, PyObject* self) {\n";
     if (1 < base_infos.size()) {
         for (const auto& binfo : base_infos) {
-             if (Cppyy::CheckDatamember(binfo.btype, "_internal_self")) {
+             if (cppjit::interop::CheckDatamember(binfo.btype, "_internal_self")) {
                  code << "    " << binfo.bname << "::_init_dispatchptr(inst, self);\n";
                  disp_inited += 1;
              }
@@ -451,12 +451,12 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
 // then a call to PythonOwns() will switch the hard ref to a weak ref, preventing
 // accidental circular references.
     if (disp_inited != base_infos.size())
-       code << "    new ((void*)&inst->_internal_self) CPyCppyy::DispatchPtr{self, true};\n";
+       code << "    new ((void*)&inst->_internal_self) cppjit::cpyrt::DispatchPtr{self, true};\n";
     code << "  }";
 
 // provide an accessor to re-initialize after round-tripping from C++ (internal)
     code << "\n  static PyObject* _get_dispatch(" << derivedName << "* inst) {\n"
-            "    CPyCppyy::PythonGILRAII python_gil_raii;\n"
+            "    cppjit::cpyrt::PythonGILRAII python_gil_raii;\n"
             "    PyObject* res = (PyObject*)inst->_internal_self;\n"
             "    Py_XINCREF(res); return res;\n  }";
 
@@ -464,14 +464,14 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
     code << "};\n}";
 
 // finally, compile the code
-    if (!Cppyy::Compile(code.str())) {
+    if (!cppjit::interop::Compile(code.str())) {
         err << "failed to compile the dispatcher code";
         return false;
     }
 
 // keep track internally of the actual C++ type (this is used in
 // CPPConstructor to call the dispatcher's one instead of the base)
-    Cppyy::TCppScope_t disp = Cppyy::GetFullScope("__cppyy_internal::"+derivedName);
+    cppjit::interop::TCppScope_t disp = cppjit::interop::GetFullScope("__cppjit_internal::"+derivedName);
     if (!disp) {
         err << "failed to retrieve the internal dispatcher";
         return false;
@@ -482,7 +482,7 @@ bool CPyCppyy::InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct,
 // that are part of the hierarchy in Python, so create it, which will cache it for
 // later use by e.g. the MemoryRegulator
     unsigned int flags = (unsigned int)(klass->fFlags & CPPScope::kIsMultiCross);
-    PyObject* disp_proxy = CPyCppyy::CreateScopeProxy(disp, 0, flags);
+    PyObject* disp_proxy = cppjit::cpyrt::CreateScopeProxy(disp, 0, flags);
     if (flags) ((CPPScope*)disp_proxy)->fFlags |= CPPScope::kIsMultiCross;
     ((CPPScope*)disp_proxy)->fFlags |= CPPScope::kIsPython;
 
diff --git a/src/CPyCppyy/src/Dispatcher.h b/src/cpyrt/Dispatcher.h
similarity index 59%
rename from src/CPyCppyy/src/Dispatcher.h
rename to src/cpyrt/Dispatcher.h
index f8d4dc5..d6226fd 100644
--- a/src/CPyCppyy/src/Dispatcher.h
+++ b/src/cpyrt/Dispatcher.h
@@ -1,16 +1,16 @@
-#ifndef CPYCPPYY_DISPATCHER_H
-#define CPYCPPYY_DISPATCHER_H
+#ifndef CPYRT_DISPATCHER_H
+#define CPYRT_DISPATCHER_H
 
 // Standard
 #include <sstream>
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class CPPScope;
 
 // helper that inserts dispatchers for virtual methods
 bool InsertDispatcher(CPPScope* klass, PyObject* bases, PyObject* dct, std::ostringstream& err);
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_DISPATCHER_H
+#endif // !CPYRT_DISPATCHER_H
diff --git a/src/CPyCppyy/src/Executors.cxx b/src/cpyrt/Executors.cxx
similarity index 72%
rename from src/CPyCppyy/src/Executors.cxx
rename to src/cpyrt/Executors.cxx
index ce86a9d..23bb809 100644
--- a/src/CPyCppyy/src/Executors.cxx
+++ b/src/cpyrt/Executors.cxx
@@ -1,6 +1,6 @@
 // Bindings
-#include "CPyCppyy.h"
-#include "Cppyy.h"
+#include "cpyrt.h"
+#include "cppjit_interop.h"
 #include "DeclareExecutors.h"
 #include "CPPInstance.h"
 #include "LowLevelViews.h"
@@ -20,7 +20,7 @@
 
 
 //- data _____________________________________________________________________
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     typedef std::unordered_map<std::string, ef_t> ExecFactories_t;
     static ExecFactories_t gExecFactories;
 
@@ -48,64 +48,64 @@ namespace {
 } // unnamed namespace
 
 #ifdef WITH_THREAD
-#define CPPYY_IMPL_GILCALL(rtype, tcode)                                     \
+#define CPPJIT_IMPL_GILCALL(rtype, tcode)                                     \
 static inline rtype GILCall##tcode(                                          \
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CPyCppyy::CallContext* ctxt)\
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, cppjit::cpyrt::CallContext* ctxt)\
 {                                                                            \
     if (!ReleasesGIL(ctxt))                                                  \
-        return Cppyy::Call##tcode(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs());\
+        return cppjit::interop::Call##tcode(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs());\
     GILControl gc{};                                                         \
-    return Cppyy::Call##tcode(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs());\
+    return cppjit::interop::Call##tcode(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs());\
 }
 #else
-#define CPPYY_IMPL_GILCALL(rtype, tcode)                                     \
+#define CPPJIT_IMPL_GILCALL(rtype, tcode)                                     \
 static inline rtype GILCall##tcode(                                          \
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CPyCppyy::CallContext* ctxt)\
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, cppjit::cpyrt::CallContext* ctxt)\
 {                                                                            \
-    return Cppyy::Call##tcode(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs());\
+    return cppjit::interop::Call##tcode(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs());\
 }
 #endif
 
-CPPYY_IMPL_GILCALL(void,           V)
-CPPYY_IMPL_GILCALL(unsigned char,  B)
-CPPYY_IMPL_GILCALL(char,           C)
-CPPYY_IMPL_GILCALL(short,          H)
-CPPYY_IMPL_GILCALL(int,            I)
-CPPYY_IMPL_GILCALL(long,           L)
-CPPYY_IMPL_GILCALL(PY_LONG_LONG,   LL)
-CPPYY_IMPL_GILCALL(float,          F)
-CPPYY_IMPL_GILCALL(double,         D)
-CPPYY_IMPL_GILCALL(PY_LONG_DOUBLE, LD)
-CPPYY_IMPL_GILCALL(void*,          R)
-
-static inline Cppyy::TCppObject_t GILCallO(Cppyy::TCppMethod_t method,
-    Cppyy::TCppObject_t self, CPyCppyy::CallContext* ctxt, Cppyy::TCppScope_t klass)
+CPPJIT_IMPL_GILCALL(void,           V)
+CPPJIT_IMPL_GILCALL(unsigned char,  B)
+CPPJIT_IMPL_GILCALL(char,           C)
+CPPJIT_IMPL_GILCALL(short,          H)
+CPPJIT_IMPL_GILCALL(int,            I)
+CPPJIT_IMPL_GILCALL(long,           L)
+CPPJIT_IMPL_GILCALL(PY_LONG_LONG,   LL)
+CPPJIT_IMPL_GILCALL(float,          F)
+CPPJIT_IMPL_GILCALL(double,         D)
+CPPJIT_IMPL_GILCALL(PY_LONG_DOUBLE, LD)
+CPPJIT_IMPL_GILCALL(void*,          R)
+
+static inline cppjit::interop::TCppObject_t GILCallO(cppjit::interop::TCppMethod_t method,
+    cppjit::interop::TCppObject_t self, cppjit::cpyrt::CallContext* ctxt, cppjit::interop::TCppScope_t klass)
 {
-    Cppyy::TCppType_t klass_ty = Cppyy::GetTypeFromScope(klass);
+    cppjit::interop::TCppType_t klass_ty = cppjit::interop::GetTypeFromScope(klass);
 #ifdef WITH_THREAD
     if (!ReleasesGIL(ctxt))
 #endif
-        return Cppyy::CallO(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs(), klass_ty);
+        return cppjit::interop::CallO(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs(), klass_ty);
 #ifdef WITH_THREAD
     GILControl gc{};
-    return Cppyy::CallO(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs(), klass_ty);
+    return cppjit::interop::CallO(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs(), klass_ty);
 #endif
 }
 
-static inline Cppyy::TCppObject_t GILCallConstructor(
-    Cppyy::TCppMethod_t method, Cppyy::TCppScope_t klass, CPyCppyy::CallContext* ctxt)
+static inline cppjit::interop::TCppObject_t GILCallConstructor(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppScope_t klass, cppjit::cpyrt::CallContext* ctxt)
 {
 #ifdef WITH_THREAD
     if (!ReleasesGIL(ctxt))
 #endif
-        return Cppyy::CallConstructor(method, klass, ctxt->GetEncodedSize(), ctxt->GetArgs());
+        return cppjit::interop::CallConstructor(method, klass, ctxt->GetEncodedSize(), ctxt->GetArgs());
 #ifdef WITH_THREAD
     GILControl gc{};
-    return Cppyy::CallConstructor(method, klass, ctxt->GetEncodedSize(), ctxt->GetArgs());
+    return cppjit::interop::CallConstructor(method, klass, ctxt->GetEncodedSize(), ctxt->GetArgs());
 #endif
 }
 
-static inline PyObject* CPyCppyy_PyText_FromLong(long cl)
+static inline PyObject* cpyrt_PyText_FromLong(long cl)
 {
 // python chars are range(256)
     if (cl < -256 || cl > 255) {
@@ -113,11 +113,11 @@ static inline PyObject* CPyCppyy_PyText_FromLong(long cl)
         return nullptr;
     }
     int c = (int)cl;
-    if (c < 0) return CPyCppyy_PyText_FromFormat("%c", 256 - std::abs(c));
-    return CPyCppyy_PyText_FromFormat("%c", c);
+    if (c < 0) return cpyrt_PyText_FromFormat("%c", 256 - std::abs(c));
+    return cpyrt_PyText_FromFormat("%c", c);
 }
 
-static inline PyObject* CPyCppyy_PyText_FromULong(unsigned long uc)
+static inline PyObject* cpyrt_PyText_FromULong(unsigned long uc)
 {
 // TODO: range check here?
     if (255 < uc) {
@@ -125,10 +125,10 @@ static inline PyObject* CPyCppyy_PyText_FromULong(unsigned long uc)
         return nullptr;
     }
     int c = (int)uc;
-    return CPyCppyy_PyText_FromFormat("%c", c);
+    return cpyrt_PyText_FromFormat("%c", c);
 }
 
-static inline PyObject* CPyCppyy_PyBool_FromLong(long b)
+static inline PyObject* cpyrt_PyBool_FromLong(long b)
 {
     PyObject* result = (bool)b ? Py_True : Py_False;
     Py_INCREF(result);
@@ -137,14 +137,14 @@ static inline PyObject* CPyCppyy_PyBool_FromLong(long b)
 
 
 //- base executor implementation ---------------------------------------------
-CPyCppyy::Executor::~Executor()
+cppjit::cpyrt::Executor::~Executor()
 {
     /* empty */
 }
 
 //- executors for built-ins --------------------------------------------------
-PyObject* CPyCppyy::BoolExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::BoolExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python bool return value
     bool retval = GILCallB(method, self, ctxt);
@@ -154,66 +154,66 @@ PyObject* CPyCppyy::BoolExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::BoolConstRefExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::BoolConstRefExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python bool return value
-    return CPyCppyy_PyBool_FromLong(*((bool*)GILCallR(method, self, ctxt)));
+    return cpyrt_PyBool_FromLong(*((bool*)GILCallR(method, self, ctxt)));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CharExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CharExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method with argument <self, ctxt>, construct python string return value
 // with the single char
-    return CPyCppyy_PyText_FromLong((int)GILCallC(method, self, ctxt));
+    return cpyrt_PyText_FromLong((int)GILCallC(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CharConstRefExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CharConstRefExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python string return value
 // with the single char
-    return CPyCppyy_PyText_FromLong(*((char*)GILCallR(method, self, ctxt)));
+    return cpyrt_PyText_FromLong(*((char*)GILCallR(method, self, ctxt)));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::UCharExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::UCharExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, args>, construct python string return value
 // with the single char
-    return CPyCppyy_PyText_FromLong((unsigned char)GILCallB(method, self, ctxt));
+    return cpyrt_PyText_FromLong((unsigned char)GILCallB(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::UCharConstRefExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::UCharConstRefExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python string return value
 // with the single char from the pointer return
-    return CPyCppyy_PyText_FromLong(*((unsigned char*)GILCallR(method, self, ctxt)));
+    return cpyrt_PyText_FromLong(*((unsigned char*)GILCallR(method, self, ctxt)));
 }
 
 //----------------------------------------------------------------------------
-PyObject *CPyCppyy::Int8ConstRefExecutor::Execute(Cppyy::TCppMethod_t method,
-                                                  Cppyy::TCppObject_t self,
+PyObject *cppjit::cpyrt::Int8ConstRefExecutor::Execute(cppjit::interop::TCppMethod_t method,
+                                                  cppjit::interop::TCppObject_t self,
                                                   CallContext *ctxt) {
   return PyInt_FromLong(*((int8_t *)GILCallR(method, self, ctxt)));
 }
 
 //----------------------------------------------------------------------------
-PyObject *CPyCppyy::UInt8ConstRefExecutor::Execute(Cppyy::TCppMethod_t method,
-                                                   Cppyy::TCppObject_t self,
+PyObject *cppjit::cpyrt::UInt8ConstRefExecutor::Execute(cppjit::interop::TCppMethod_t method,
+                                                   cppjit::interop::TCppObject_t self,
                                                    CallContext *ctxt) {
   return PyInt_FromLong(*((uint8_t *)GILCallR(method, self, ctxt)));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::WCharExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::WCharExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, args>, construct python string return value
 // with the single wide char
@@ -222,8 +222,8 @@ PyObject* CPyCppyy::WCharExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::Char16Executor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::Char16Executor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, args>, construct python string return value
 // with the single char16
@@ -232,8 +232,8 @@ PyObject* CPyCppyy::Char16Executor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::Char32Executor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::Char32Executor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, args>, construct python string return value
 // with the single char32
@@ -242,56 +242,56 @@ PyObject* CPyCppyy::Char32Executor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::IntExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::IntExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python int return value
     return PyInt_FromLong((int)GILCallI(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::Int8Executor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::Int8Executor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python int return value
     return PyInt_FromLong((int8_t)GILCallC(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::UInt8Executor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::UInt8Executor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python int return value
     return PyInt_FromLong((uint8_t)GILCallB(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::ShortExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::ShortExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python int return value
     return PyInt_FromLong((short)GILCallH(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::LongExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::LongExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python long return value
     return PyLong_FromLong((long)GILCallL(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::ULongExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::ULongExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python unsigned long return value
     return PyLong_FromUnsignedLong((unsigned long)GILCallLL(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::LongLongExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::LongLongExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python long long return value
     PY_LONG_LONG result = GILCallLL(method, self, ctxt);
@@ -299,8 +299,8 @@ PyObject* CPyCppyy::LongLongExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::ULongLongExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::ULongLongExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python unsigned long long return value
     PY_ULONG_LONG result = (PY_ULONG_LONG)GILCallLL(method, self, ctxt);
@@ -308,31 +308,31 @@ PyObject* CPyCppyy::ULongLongExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::FloatExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::FloatExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python float return value
     return PyFloat_FromDouble((double)GILCallF(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::DoubleExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::DoubleExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python float return value
     return PyFloat_FromDouble((double)GILCallD(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::LongDoubleExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::LongDoubleExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python float return value
     return PyFloat_FromDouble((double)GILCallLD(method, self, ctxt));
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::RefExecutor::SetAssignable(PyObject* pyobject)
+bool cppjit::cpyrt::RefExecutor::SetAssignable(PyObject* pyobject)
 {
 // prepare "buffer" for by-ref returns, used with __setitem__
     if (pyobject) {
@@ -346,9 +346,9 @@ bool CPyCppyy::RefExecutor::SetAssignable(PyObject* pyobject)
 }
 
 //----------------------------------------------------------------------------
-#define CPPYY_IMPL_REFEXEC(name, type, stype, F1, F2)                        \
-PyObject* CPyCppyy::name##RefExecutor::Execute(                              \
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt) \
+#define CPPJIT_IMPL_REFEXEC(name, type, stype, F1, F2)                        \
+PyObject* cppjit::cpyrt::name##RefExecutor::Execute(                              \
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt) \
 {                                                                            \
     type* ref = (type*)GILCallR(method, self, ctxt);                         \
     if (!ref) { /* can happen if wrapper compilation fails */                \
@@ -368,22 +368,22 @@ PyObject* CPyCppyy::name##RefExecutor::Execute(                              \
     }                                                                        \
 }
 
-CPPYY_IMPL_REFEXEC(Bool,       bool,           long,           CPyCppyy_PyBool_FromLong,    PyLong_AsLong)
-CPPYY_IMPL_REFEXEC(Char,       char,           long,           CPyCppyy_PyText_FromLong,    PyLong_AsLong)
-CPPYY_IMPL_REFEXEC(UChar,      unsigned char,  unsigned long,  CPyCppyy_PyText_FromULong,   PyLongOrInt_AsULong)
-CPPYY_IMPL_REFEXEC(Int8,       int8_t,         long,           PyInt_FromLong,              PyLong_AsLong)
-CPPYY_IMPL_REFEXEC(UInt8,      uint8_t,        unsigned long,  PyInt_FromLong,              PyLongOrInt_AsULong)
-CPPYY_IMPL_REFEXEC(Short,      short,          long,           PyInt_FromLong,              PyLong_AsLong)
-CPPYY_IMPL_REFEXEC(UShort,     unsigned short, unsigned long,  PyInt_FromLong,              PyLongOrInt_AsULong)
-CPPYY_IMPL_REFEXEC(Int,        int,            long,           PyInt_FromLong,              PyLong_AsLong)
-CPPYY_IMPL_REFEXEC(UInt,       unsigned int,   unsigned long,  PyLong_FromUnsignedLong,     PyLongOrInt_AsULong)
-CPPYY_IMPL_REFEXEC(Long,       long,           long,           PyLong_FromLong,             PyLong_AsLong)
-CPPYY_IMPL_REFEXEC(ULong,      unsigned long,  unsigned long,  PyLong_FromUnsignedLong,     PyLongOrInt_AsULong)
-CPPYY_IMPL_REFEXEC(LongLong,   PY_LONG_LONG,   PY_LONG_LONG,   PyLong_FromLongLong,         PyLong_AsLongLong)
-CPPYY_IMPL_REFEXEC(ULongLong,  PY_ULONG_LONG,  PY_ULONG_LONG,  PyLong_FromUnsignedLongLong, PyLongOrInt_AsULong64)
-CPPYY_IMPL_REFEXEC(Float,      float,          double,         PyFloat_FromDouble,          PyFloat_AsDouble)
-CPPYY_IMPL_REFEXEC(Double,     double,         double,         PyFloat_FromDouble,          PyFloat_AsDouble)
-CPPYY_IMPL_REFEXEC(LongDouble, PY_LONG_DOUBLE, PY_LONG_DOUBLE, PyFloat_FromDouble,          PyFloat_AsDouble)
+CPPJIT_IMPL_REFEXEC(Bool,       bool,           long,           cpyrt_PyBool_FromLong,    PyLong_AsLong)
+CPPJIT_IMPL_REFEXEC(Char,       char,           long,           cpyrt_PyText_FromLong,    PyLong_AsLong)
+CPPJIT_IMPL_REFEXEC(UChar,      unsigned char,  unsigned long,  cpyrt_PyText_FromULong,   PyLongOrInt_AsULong)
+CPPJIT_IMPL_REFEXEC(Int8,       int8_t,         long,           PyInt_FromLong,              PyLong_AsLong)
+CPPJIT_IMPL_REFEXEC(UInt8,      uint8_t,        unsigned long,  PyInt_FromLong,              PyLongOrInt_AsULong)
+CPPJIT_IMPL_REFEXEC(Short,      short,          long,           PyInt_FromLong,              PyLong_AsLong)
+CPPJIT_IMPL_REFEXEC(UShort,     unsigned short, unsigned long,  PyInt_FromLong,              PyLongOrInt_AsULong)
+CPPJIT_IMPL_REFEXEC(Int,        int,            long,           PyInt_FromLong,              PyLong_AsLong)
+CPPJIT_IMPL_REFEXEC(UInt,       unsigned int,   unsigned long,  PyLong_FromUnsignedLong,     PyLongOrInt_AsULong)
+CPPJIT_IMPL_REFEXEC(Long,       long,           long,           PyLong_FromLong,             PyLong_AsLong)
+CPPJIT_IMPL_REFEXEC(ULong,      unsigned long,  unsigned long,  PyLong_FromUnsignedLong,     PyLongOrInt_AsULong)
+CPPJIT_IMPL_REFEXEC(LongLong,   PY_LONG_LONG,   PY_LONG_LONG,   PyLong_FromLongLong,         PyLong_AsLongLong)
+CPPJIT_IMPL_REFEXEC(ULongLong,  PY_ULONG_LONG,  PY_ULONG_LONG,  PyLong_FromUnsignedLongLong, PyLongOrInt_AsULong64)
+CPPJIT_IMPL_REFEXEC(Float,      float,          double,         PyFloat_FromDouble,          PyFloat_AsDouble)
+CPPJIT_IMPL_REFEXEC(Double,     double,         double,         PyFloat_FromDouble,          PyFloat_AsDouble)
+CPPJIT_IMPL_REFEXEC(LongDouble, PY_LONG_DOUBLE, PY_LONG_DOUBLE, PyFloat_FromDouble,          PyFloat_AsDouble)
 
 template<typename T>
 static inline PyObject* PyComplex_FromComplex(const std::complex<T>& c) {
@@ -396,16 +396,16 @@ static inline std::complex<T> PyComplex_AsComplex(PyObject* pycplx) {
     return std::complex<T>(cplx.real, cplx.imag);
 }
 
-CPPYY_IMPL_REFEXEC(ComplexD, std::complex<double>,
+CPPJIT_IMPL_REFEXEC(ComplexD, std::complex<double>,
     std::complex<double>, PyComplex_FromComplex<double>, PyComplex_AsComplex<double>)
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::STLStringRefExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::STLStringRefExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, return python string return value
-    static Cppyy::TCppScope_t sSTLStringScope = Cppyy::GetFullScope("std::string");
+    static cppjit::interop::TCppScope_t sSTLStringScope = cppjit::interop::GetFullScope("std::string");
 
     std::string* result = (std::string*)GILCallR(method, self, ctxt);
     if (!fAssignable) {
@@ -413,13 +413,13 @@ PyObject* CPyCppyy::STLStringRefExecutor::Execute(
         return BindCppObjectNoCast((void*)rescp, sSTLStringScope, CPPInstance::kIsOwner);
     }
 
-    if (!CPyCppyy_PyText_Check(fAssignable)) {
+    if (!cpyrt_PyText_Check(fAssignable)) {
         PyErr_Format(PyExc_TypeError, "wrong type in assignment (string expected)");
         return nullptr;
     }
 
     *result = std::string(
-        CPyCppyy_PyText_AsString(fAssignable), CPyCppyy_PyText_GET_SIZE(fAssignable));
+        cpyrt_PyText_AsString(fAssignable), cpyrt_PyText_GET_SIZE(fAssignable));
 
     Py_DECREF(fAssignable);
     fAssignable = nullptr;
@@ -428,8 +428,8 @@ PyObject* CPyCppyy::STLStringRefExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::VoidExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::VoidExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, return None
     GILCallV(method, self, ctxt);
@@ -438,8 +438,8 @@ PyObject* CPyCppyy::VoidExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CStringExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CStringExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python string return value
     char* result = (char*)GILCallR(method, self, ctxt);
@@ -448,12 +448,12 @@ PyObject* CPyCppyy::CStringExecutor::Execute(
         return PyStrings::gEmptyString;
     }
 
-    return CPyCppyy_PyText_FromString(result);
+    return cpyrt_PyText_FromString(result);
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CStringRefExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CStringRefExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python string return value
     char** result = (char**)GILCallR(method, self, ctxt);
@@ -462,12 +462,12 @@ PyObject* CPyCppyy::CStringRefExecutor::Execute(
         return PyStrings::gEmptyString;
     }
 
-    return CPyCppyy_PyText_FromString(*result);
+    return cpyrt_PyText_FromString(*result);
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::WCStringExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::WCStringExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python unicode return value
     wchar_t* result = (wchar_t*)GILCallR(method, self, ctxt);
@@ -480,8 +480,8 @@ PyObject* CPyCppyy::WCStringExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CString16Executor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CString16Executor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python unicode return value
     char16_t* result = (char16_t*)GILCallR(method, self, ctxt);
@@ -495,8 +495,8 @@ PyObject* CPyCppyy::CString16Executor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CString32Executor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::CString32Executor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python unicode return value
     char32_t* result = (char32_t*)GILCallR(method, self, ctxt);
@@ -511,8 +511,8 @@ PyObject* CPyCppyy::CString32Executor::Execute(
 
 
 //- pointer/array executors --------------------------------------------------
-PyObject* CPyCppyy::VoidArrayExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::VoidArrayExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python long return value
     intptr_t* result = (intptr_t*)GILCallR(method, self, ctxt);
@@ -524,42 +524,42 @@ PyObject* CPyCppyy::VoidArrayExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-#define CPPYY_IMPL_ARRAY_EXEC(name, type, suffix)                            \
-PyObject* CPyCppyy::name##ArrayExecutor::Execute(                            \
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt) \
+#define CPPJIT_IMPL_ARRAY_EXEC(name, type, suffix)                            \
+PyObject* cppjit::cpyrt::name##ArrayExecutor::Execute(                            \
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt) \
 {                                                                            \
     return CreateLowLevelView##suffix((type*)GILCallR(method, self, ctxt), fShape);  \
 }
 
-CPPYY_IMPL_ARRAY_EXEC(Bool,     bool,                    )
-CPPYY_IMPL_ARRAY_EXEC(SChar,    signed char,             )
-CPPYY_IMPL_ARRAY_EXEC(UChar,    unsigned char,           )
-CPPYY_IMPL_ARRAY_EXEC(Byte,     std::byte,               )
-CPPYY_IMPL_ARRAY_EXEC(Int8,     int8_t,               _i8)
-CPPYY_IMPL_ARRAY_EXEC(UInt8,    uint8_t,              _i8)
-CPPYY_IMPL_ARRAY_EXEC(Short,    short,                   )
-CPPYY_IMPL_ARRAY_EXEC(UShort,   unsigned short,          )
-CPPYY_IMPL_ARRAY_EXEC(Int,      int,                     )
-CPPYY_IMPL_ARRAY_EXEC(UInt,     unsigned int,            )
-CPPYY_IMPL_ARRAY_EXEC(Long,     long,                    )
-CPPYY_IMPL_ARRAY_EXEC(ULong,    unsigned long,           )
-CPPYY_IMPL_ARRAY_EXEC(LLong,    long long,               )
-CPPYY_IMPL_ARRAY_EXEC(ULLong,   unsigned long long,      )
-CPPYY_IMPL_ARRAY_EXEC(Float,    float,                   )
-CPPYY_IMPL_ARRAY_EXEC(Double,   double,                  )
-CPPYY_IMPL_ARRAY_EXEC(LDouble,  long double,             )
-CPPYY_IMPL_ARRAY_EXEC(ComplexF, std::complex<float>,     )
-CPPYY_IMPL_ARRAY_EXEC(ComplexD, std::complex<double>,    )
-CPPYY_IMPL_ARRAY_EXEC(ComplexI, std::complex<int>,       )
-CPPYY_IMPL_ARRAY_EXEC(ComplexL, std::complex<long>,      )
+CPPJIT_IMPL_ARRAY_EXEC(Bool,     bool,                    )
+CPPJIT_IMPL_ARRAY_EXEC(SChar,    signed char,             )
+CPPJIT_IMPL_ARRAY_EXEC(UChar,    unsigned char,           )
+CPPJIT_IMPL_ARRAY_EXEC(Byte,     std::byte,               )
+CPPJIT_IMPL_ARRAY_EXEC(Int8,     int8_t,               _i8)
+CPPJIT_IMPL_ARRAY_EXEC(UInt8,    uint8_t,              _i8)
+CPPJIT_IMPL_ARRAY_EXEC(Short,    short,                   )
+CPPJIT_IMPL_ARRAY_EXEC(UShort,   unsigned short,          )
+CPPJIT_IMPL_ARRAY_EXEC(Int,      int,                     )
+CPPJIT_IMPL_ARRAY_EXEC(UInt,     unsigned int,            )
+CPPJIT_IMPL_ARRAY_EXEC(Long,     long,                    )
+CPPJIT_IMPL_ARRAY_EXEC(ULong,    unsigned long,           )
+CPPJIT_IMPL_ARRAY_EXEC(LLong,    long long,               )
+CPPJIT_IMPL_ARRAY_EXEC(ULLong,   unsigned long long,      )
+CPPJIT_IMPL_ARRAY_EXEC(Float,    float,                   )
+CPPJIT_IMPL_ARRAY_EXEC(Double,   double,                  )
+CPPJIT_IMPL_ARRAY_EXEC(LDouble,  long double,             )
+CPPJIT_IMPL_ARRAY_EXEC(ComplexF, std::complex<float>,     )
+CPPJIT_IMPL_ARRAY_EXEC(ComplexD, std::complex<double>,    )
+CPPJIT_IMPL_ARRAY_EXEC(ComplexI, std::complex<int>,       )
+CPPJIT_IMPL_ARRAY_EXEC(ComplexL, std::complex<long>,      )
 
 
 //- special cases ------------------------------------------------------------
-#define CPPYY_COMPLEX_EXEC(code, type)                                       \
-PyObject* CPyCppyy::Complex##code##Executor::Execute(                        \
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt) \
+#define CPPJIT_COMPLEX_EXEC(code, type)                                       \
+PyObject* cppjit::cpyrt::Complex##code##Executor::Execute(                        \
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt) \
 {                                                                            \
-    static Cppyy::TCppScope_t scopeid = Cppyy::GetScope("std::complex<"#type">");\
+    static cppjit::interop::TCppScope_t scopeid = cppjit::interop::GetScope("std::complex<"#type">");\
     std::complex<type>* result =                                             \
         (std::complex<type>*)GILCallO(method, self, ctxt, scopeid).data;     \
     if (!result) {                                                           \
@@ -568,20 +568,20 @@ PyObject* CPyCppyy::Complex##code##Executor::Execute(                        \
     }                                                                        \
                                                                              \
     PyObject* pyres = PyComplex_FromDoubles(result->real(), result->imag()); \
-    ::operator delete(result); /* Cppyy::CallO calls ::operator new */       \
+    ::operator delete(result); /* cppjit::interop::CallO calls ::operator new */       \
     return pyres;                                                            \
 }
 
-CPPYY_COMPLEX_EXEC(D, double)
+CPPJIT_COMPLEX_EXEC(D, double)
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::STLStringExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::STLStringExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python string return value
 
 // TODO: make use of GILLCallS (?!)
-    static Cppyy::TCppScope_t sSTLStringScope = Cppyy::GetFullScope("std::string");
+    static cppjit::interop::TCppScope_t sSTLStringScope = cppjit::interop::GetFullScope("std::string");
     std::string* result = (std::string*)GILCallO(method, self, ctxt, sSTLStringScope).data;
     if (!result)
         result = new std::string{};
@@ -594,11 +594,11 @@ PyObject* CPyCppyy::STLStringExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::STLWStringExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::STLWStringExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python string return value
-    static Cppyy::TCppScope_t sSTLWStringScope = Cppyy::GetFullScope("std::wstring");
+    static cppjit::interop::TCppScope_t sSTLWStringScope = cppjit::interop::GetFullScope("std::wstring");
     std::wstring* result = (std::wstring*)GILCallO(method, self, ctxt, sSTLWStringScope).data;
     if (!result) {
         wchar_t w = L'\0';
@@ -606,32 +606,32 @@ PyObject* CPyCppyy::STLWStringExecutor::Execute(
     }
 
     PyObject* pyresult = PyUnicode_FromWideChar(result->c_str(), result->size());
-    delete result; // Cppyy::CallO allocates and constructs a string, so it must be properly destroyed
+    delete result; // cppjit::interop::CallO allocates and constructs a string, so it must be properly destroyed
 
     return pyresult;
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::InstancePtrExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::InstancePtrExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python proxy object return value
     return BindCppObject((void*)GILCallR(method, self, ctxt), fClass);
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::InstanceExecutor::InstanceExecutor(Cppyy::TCppScope_t klass) :
+cppjit::cpyrt::InstanceExecutor::InstanceExecutor(cppjit::interop::TCppScope_t klass) :
     fClass(klass), fFlags(CPPInstance::kIsValue | CPPInstance::kIsOwner)
 {
     /* empty */
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::InstanceExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::InstanceExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execution will bring a temporary in existence
-    Cppyy::TCppObject_t value = GILCallO(method, self, ctxt, fClass);
+    cppjit::interop::TCppObject_t value = GILCallO(method, self, ctxt, fClass);
 
     if (!value) {
         if (!PyErr_Occurred())         // callee may have set a python error itself
@@ -651,7 +651,7 @@ PyObject* CPyCppyy::InstanceExecutor::Execute(
 
 
 //----------------------------------------------------------------------------
-CPyCppyy::IteratorExecutor::IteratorExecutor(Cppyy::TCppScope_t klass) :
+cppjit::cpyrt::IteratorExecutor::IteratorExecutor(cppjit::interop::TCppScope_t klass) :
     InstanceExecutor(klass)
 {
     fFlags |= CPPInstance::kNoMemReg | CPPInstance::kNoWrapConv;     // adds to flags from base class
@@ -659,8 +659,8 @@ CPyCppyy::IteratorExecutor::IteratorExecutor(Cppyy::TCppScope_t klass) :
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::InstanceRefExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::InstanceRefExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // executor binds the result to the left-hand side, overwriting if an old object
     PyObject* result = BindCppObject((void*)GILCallR(method, self, ctxt), fClass);
@@ -672,9 +672,9 @@ PyObject* CPyCppyy::InstanceRefExecutor::Execute(
         if (!assign) {
             PyErr_Clear();
             PyObject* descr = PyObject_Str(result);
-            if (descr && CPyCppyy_PyText_CheckExact(descr)) {
+            if (descr && cpyrt_PyText_CheckExact(descr)) {
                 PyErr_Format(PyExc_TypeError, "cannot assign to return object (%s)",
-                             CPyCppyy_PyText_AsString(descr));
+                             cpyrt_PyText_AsString(descr));
             } else {
                 PyErr_SetString(PyExc_TypeError, "cannot assign to result");
             }
@@ -704,15 +704,15 @@ static inline PyObject* SetInstanceCheckError(PyObject* pyobj) {
     PyObject* pystr = PyObject_Str(pyobj);
     if (pystr) {
         PyErr_Format(PyExc_TypeError,
-           "C++ object expected, got %s", CPyCppyy_PyText_AsString(pystr));
+           "C++ object expected, got %s", cpyrt_PyText_AsString(pystr));
         Py_DECREF(pystr);
     } else
         PyErr_SetString(PyExc_TypeError, "C++ object expected");
     return nullptr;
 }
 
-PyObject* CPyCppyy::InstancePtrPtrExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::InstancePtrPtrExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python C++ proxy object
 // return ptr value
@@ -734,8 +734,8 @@ PyObject* CPyCppyy::InstancePtrPtrExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::InstancePtrRefExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::InstancePtrRefExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct python C++ proxy object
 // ignoring ref) return ptr value
@@ -757,8 +757,8 @@ PyObject* CPyCppyy::InstancePtrRefExecutor::Execute(
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::InstanceArrayExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::InstanceArrayExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, construct TupleOfInstances from
 // return value
@@ -766,25 +766,25 @@ PyObject* CPyCppyy::InstanceArrayExecutor::Execute(
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::ConstructorExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t klass, CallContext* ctxt)
+PyObject* cppjit::cpyrt::ConstructorExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t klass, CallContext* ctxt)
 {
 // package return address in PyObject* for caller to handle appropriately (see
 // CPPConstructor for the actual build of the PyObject)
-    return (PyObject*)GILCallConstructor(method, Cppyy::TCppScope_t(klass.data), ctxt).data;
+    return (PyObject*)GILCallConstructor(method, cppjit::interop::TCppScope_t(klass.data), ctxt).data;
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::PyObjectExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::PyObjectExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, return python object
     return (PyObject*)GILCallR(method, self, ctxt);
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::FunctionPointerExecutor::Execute(
-    Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, CallContext* ctxt)
+PyObject* cppjit::cpyrt::FunctionPointerExecutor::Execute(
+    cppjit::interop::TCppMethod_t method, cppjit::interop::TCppObject_t self, CallContext* ctxt)
 {
 // execute <method> with argument <self, ctxt>, return std::function from func ptr
 
@@ -803,7 +803,7 @@ PyObject* CPyCppyy::FunctionPointerExecutor::Execute(
 }
 
 //- factories ----------------------------------------------------------------
-CPyCppyy::Executor* CPyCppyy::CreateExecutor(const std::string& fullType, cdims_t dims)
+cppjit::cpyrt::Executor* cppjit::cpyrt::CreateExecutor(const std::string& fullType, cdims_t dims)
 {
 // The matching of the fulltype to an executor factory goes through up to 4 levels:
 //   1) full, qualified match
@@ -822,7 +822,7 @@ CPyCppyy::Executor* CPyCppyy::CreateExecutor(const std::string& fullType, cdims_
         return (h->second)(dims);
 
 // resolve typedefs etc.
-    const std::string resolvedType = Cppyy::ResolveName(fullType);
+    const std::string resolvedType = cppjit::interop::ResolveName(fullType);
 
 // a full, qualified matching executor is preferred
     if (resolvedType != fullType) {
@@ -866,7 +866,7 @@ CPyCppyy::Executor* CPyCppyy::CreateExecutor(const std::string& fullType, cdims_
 
 // C++ classes and special cases
     Executor* result = 0;
-    if (Cppyy::TCppScope_t klass = Cppyy::GetFullScope(realType)) {
+    if (cppjit::interop::TCppScope_t klass = cppjit::interop::GetFullScope(realType)) {
         if (Utility::IsSTLIterator(realType) || gIteratorTypes.find(fullType) != gIteratorTypes.end()) {
             if (cpd == "")
                 return new IteratorExecutor(klass);
@@ -909,7 +909,7 @@ CPyCppyy::Executor* CPyCppyy::CreateExecutor(const std::string& fullType, cdims_
    return result;                  // may still be null
 }
 
-CPyCppyy::Executor* CPyCppyy::CreateExecutor(Cppyy::TCppType_t type, cdims_t dims)
+cppjit::cpyrt::Executor* cppjit::cpyrt::CreateExecutor(cppjit::interop::TCppType_t type, cdims_t dims)
 {
 // The matching of the fulltype to an executor factory goes through up to 4 levels:
 //   1) full, qualified match
@@ -920,7 +920,7 @@ CPyCppyy::Executor* CPyCppyy::CreateExecutor(Cppyy::TCppType_t type, cdims_t dim
 // If all fails, void is used, which will cause the return type to be ignored on use
 
 // an exactly matching executor is best
-    std::string fullType = Cppyy::GetTypeAsString(type);
+    std::string fullType = cppjit::interop::GetTypeAsString(type);
     if (fullType.size() >= 2 && fullType.compare(fullType.size() - 2, 2, " &") == 0)
         fullType = fullType.substr(0, fullType.size() - 2) + "&";
 
@@ -929,18 +929,18 @@ CPyCppyy::Executor* CPyCppyy::CreateExecutor(Cppyy::TCppType_t type, cdims_t dim
         return (h->second)(dims);
 
 // resolve typedefs etc.
-    Cppyy::TCppType_t resolvedType = Cppyy::ResolveType(type);
+    cppjit::interop::TCppType_t resolvedType = cppjit::interop::ResolveType(type);
     {
         // if resolvedType is a reference to enum
         // then it should be reduced to reference
         // to the underlying interger
-        resolvedType = Cppyy::ResolveEnumReferenceType(resolvedType);
+        resolvedType = cppjit::interop::ResolveEnumReferenceType(resolvedType);
         // similarly for pointers
-        resolvedType = Cppyy::ResolveEnumPointerType(resolvedType);
+        resolvedType = cppjit::interop::ResolveEnumPointerType(resolvedType);
     }
     // FIXME: avoid string comparisons and parsing
-    std::string resolvedTypeStr = Cppyy::GetTypeAsString(resolvedType);
-    if (Cppyy::IsFunctionPointerType(resolvedType)) {
+    std::string resolvedTypeStr = cppjit::interop::GetTypeAsString(resolvedType);
+    if (cppjit::interop::IsFunctionPointerType(resolvedType)) {
         resolvedTypeStr.erase(std::remove(resolvedTypeStr.begin(), resolvedTypeStr.end(), ' '), resolvedTypeStr.end());
         if (resolvedTypeStr.rfind("(void)") != std::string::npos)
             resolvedTypeStr = resolvedTypeStr.substr(0, resolvedTypeStr.size() - 6) + "()";
@@ -956,8 +956,8 @@ CPyCppyy::Executor* CPyCppyy::CreateExecutor(Cppyy::TCppType_t type, cdims_t dim
 //-- nothing? ok, collect information about the type and possible qualifiers/decorators
     bool isConst = strncmp(resolvedTypeStr.c_str(), "const", 5)  == 0;
     const std::string& cpd = TypeManip::compound(resolvedTypeStr);
-    Cppyy::TCppType_t realType = Cppyy::IsFunctionPointerType(resolvedType) ? resolvedType : Cppyy::GetRealType(resolvedType);
-    std::string realTypeStr = Cppyy::IsFunctionPointerType(resolvedType) ? resolvedTypeStr : Cppyy::GetTypeAsString(realType);
+    cppjit::interop::TCppType_t realType = cppjit::interop::IsFunctionPointerType(resolvedType) ? resolvedType : cppjit::interop::GetRealType(resolvedType);
+    std::string realTypeStr = cppjit::interop::IsFunctionPointerType(resolvedType) ? resolvedTypeStr : cppjit::interop::GetTypeAsString(realType);
     const std::string compounded = cpd.empty() ? realTypeStr : realTypeStr + cpd;
 
 // accept unqualified type (as python does not know about qualifiers)
@@ -990,8 +990,8 @@ CPyCppyy::Executor* CPyCppyy::CreateExecutor(Cppyy::TCppType_t type, cdims_t dim
 
 // C++ classes and special cases
     Executor* result = 0;
-    if (Cppyy::IsClassType(realType)) {
-        Cppyy::TCppScope_t klass = Cppyy::GetScopeFromType(realType);
+    if (cppjit::interop::IsClassType(realType)) {
+        cppjit::interop::TCppScope_t klass = cppjit::interop::GetScopeFromType(realType);
         if (resolvedTypeStr.find("iterator") != std::string::npos || gIteratorTypes.find(fullType) != gIteratorTypes.end()) {
             if (cpd == "")
                 return new IteratorExecutor(klass);
@@ -1035,16 +1035,16 @@ CPyCppyy::Executor* CPyCppyy::CreateExecutor(Cppyy::TCppType_t type, cdims_t dim
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-void CPyCppyy::DestroyExecutor(Executor* p)
+CPYRT_EXPORT
+void cppjit::cpyrt::DestroyExecutor(Executor* p)
 {
     if (p && p->HasState())
         delete p;  // state-less executors are always shared
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-bool CPyCppyy::RegisterExecutor(const std::string& name, ef_t fac)
+CPYRT_EXPORT
+bool cppjit::cpyrt::RegisterExecutor(const std::string& name, ef_t fac)
 {
 // register a custom executor
     auto f = gExecFactories.find(name);
@@ -1056,8 +1056,8 @@ bool CPyCppyy::RegisterExecutor(const std::string& name, ef_t fac)
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-bool CPyCppyy::RegisterExecutorAlias(const std::string& name, const std::string& target)
+CPYRT_EXPORT
+bool cppjit::cpyrt::RegisterExecutorAlias(const std::string& name, const std::string& target)
 {
 // register a custom executor that is a reference to an existing converter
     auto f = gExecFactories.find(name);
@@ -1073,8 +1073,8 @@ bool CPyCppyy::RegisterExecutorAlias(const std::string& name, const std::string&
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-bool CPyCppyy::UnregisterExecutor(const std::string& name)
+CPYRT_EXPORT
+bool cppjit::cpyrt::UnregisterExecutor(const std::string& name)
 {
 // remove a custom executor
     auto f = gExecFactories.find(name);
@@ -1086,8 +1086,8 @@ bool CPyCppyy::UnregisterExecutor(const std::string& name)
 }
 
 //----------------------------------------------------------------------------
-CPYCPPYY_EXPORT
-void* CPyCppyy::CallVoidP(Cppyy::TCppMethod_t meth, Cppyy::TCppObject_t obj, CallContext* ctxt)
+CPYRT_EXPORT
+void* cppjit::cpyrt::CallVoidP(cppjit::interop::TCppMethod_t meth, cppjit::interop::TCppObject_t obj, CallContext* ctxt)
 {
      return GILCallR(meth, obj, ctxt);
 }
@@ -1096,7 +1096,7 @@ void* CPyCppyy::CallVoidP(Cppyy::TCppMethod_t meth, Cppyy::TCppObject_t obj, Cal
 //----------------------------------------------------------------------------
 namespace {
 
-using namespace CPyCppyy;
+using namespace cppjit::cpyrt;
 
 #define WSTRING1 "std::basic_string<wchar_t>"
 #define WSTRING2 "std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>"
@@ -1114,7 +1114,7 @@ struct InitExecFactories_t {
 public:
     InitExecFactories_t() {
     // load all executor factories in the global map 'gExecFactories'
-        CPyCppyy::ExecFactories_t& gf = gExecFactories;
+        cppjit::cpyrt::ExecFactories_t& gf = gExecFactories;
 
     // factories for built-ins
         gf["bool"] =                        (ef_t)+[](cdims_t) { static BoolExecutor e{};          return &e; };
@@ -1227,7 +1227,7 @@ struct InitExecFactories_t {
         gf[CCOMPLEX_F " ptr"] =             gf["std::complex<float> ptr"];
         gf[CCOMPLEX_D " ptr"] =             gf["std::complex<double> ptr"];
 
-        // We always need these executors when cppyy is based on an unpatched
+        // We always need these executors when cppjit is based on an unpatched
         // ROOT, because the "long long" types are always converted to Long64_t
         // and ULong64_t already at the ROOT Meta level.
         // See https://github.com/root-project/root/issues/15872#issuecomment-2174092763
diff --git a/src/cpyrt/Executors.h b/src/cpyrt/Executors.h
new file mode 100644
index 0000000..4a8d5d9
--- /dev/null
+++ b/src/cpyrt/Executors.h
@@ -0,0 +1,51 @@
+#ifndef CPYRT_EXECUTORS_H
+#define CPYRT_EXECUTORS_H
+
+#include "Python.h"
+#include "cppjit_interop.h"
+
+// Bindings
+#include "Dimensions.h"
+
+// Standard
+#include <string>
+
+
+namespace cppjit::cpyrt {
+
+struct CallContext;
+
+class CPYRT_CLASS_EXPORT Executor {
+public:
+    virtual ~Executor();
+    virtual PyObject* Execute(
+        cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*) = 0;
+    virtual bool HasState() { return false; }
+};
+
+// special case needed for CPPSetItem
+class RefExecutor : public Executor {
+public:
+    RefExecutor() : fAssignable(nullptr) {}
+    virtual bool SetAssignable(PyObject*);
+    bool HasState() override { return true; }
+
+protected:
+    PyObject* fAssignable;
+};
+
+// create/destroy executor from fully qualified type (public API)
+CPYRT_EXPORT Executor* CreateExecutor(const std::string& fullType, cdims_t = 0);
+CPYRT_EXPORT Executor* CreateExecutor(cppjit::interop::TCppType_t type, cdims_t = 0);
+CPYRT_EXPORT void DestroyExecutor(Executor* p);
+typedef Executor* (*ef_t) (cdims_t);
+CPYRT_EXPORT bool RegisterExecutor(const std::string& name, ef_t fac);
+CPYRT_EXPORT bool RegisterExecutorAlias(const std::string& name, const std::string& target);
+CPYRT_EXPORT bool UnregisterExecutor(const std::string& name);
+
+// helper for the actual call
+CPYRT_EXPORT void* CallVoidP(cppjit::interop::TCppMethod_t, cppjit::interop::TCppObject_t, CallContext*);
+
+} // namespace cppjit::cpyrt
+
+#endif // !CPYRT_EXECUTORS_H
diff --git a/src/CPyCppyy/src/LowLevelViews.cxx b/src/cpyrt/LowLevelViews.cxx
similarity index 85%
rename from src/CPyCppyy/src/LowLevelViews.cxx
rename to src/cpyrt/LowLevelViews.cxx
index 870a992..85bcd84 100644
--- a/src/CPyCppyy/src/LowLevelViews.cxx
+++ b/src/cpyrt/LowLevelViews.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "LowLevelViews.h"
 #include "Converters.h"
 #include "CustomPyTypes.h"
@@ -15,7 +15,7 @@
 //= memoryview-like object ===================================================
 // This is largely setup just like Python builtin memory view objects, with
 // the exceptions that there is no need of a "base" object (it views on C++
-// memory, not a Python object with a buffer interface), it uses the CPyCppyy
+// memory, not a Python object with a buffer interface), it uses the cpyrt
 // converters, and typed results and assignments are supported. Code reused
 // under PSF License Version 2.
 
@@ -36,16 +36,16 @@ static inline void set_strides(Py_buffer& view, size_t itemsize, bool isfix) {
 }
 
 
-//= CPyCppyy low level view construction/destruction =========================
-static CPyCppyy::LowLevelView* ll_new(PyTypeObject* subtype, PyObject*, PyObject*)
+//= cpyrt low level view construction/destruction =========================
+static cppjit::cpyrt::LowLevelView* ll_new(PyTypeObject* subtype, PyObject*, PyObject*)
 {
 // Create a new low level ptr type
-    CPyCppyy::LowLevelView* pyobj = (CPyCppyy::LowLevelView*)subtype->tp_alloc(subtype, 0);
+    cppjit::cpyrt::LowLevelView* pyobj = (cppjit::cpyrt::LowLevelView*)subtype->tp_alloc(subtype, 0);
     if (!pyobj)
         return nullptr;
 
     memset(&pyobj->fBufInfo, 0, sizeof(Py_buffer));
-    (intptr_t&)pyobj->fBufInfo.internal |= CPyCppyy::LowLevelView::kIsCppArray;
+    (intptr_t&)pyobj->fBufInfo.internal |= cppjit::cpyrt::LowLevelView::kIsCppArray;
     pyobj->fBuf = nullptr;
     pyobj->fConverter = nullptr;
     pyobj->fElemCnv   = nullptr;
@@ -54,13 +54,13 @@ static CPyCppyy::LowLevelView* ll_new(PyTypeObject* subtype, PyObject*, PyObject
 }
 
 //----------------------------------------------------------------------------
-static void ll_dealloc(CPyCppyy::LowLevelView* pyobj)
+static void ll_dealloc(cppjit::cpyrt::LowLevelView* pyobj)
 {
 // Destruction requires the deletion of the converter (if any)
     PyMem_Free(pyobj->fBufInfo.shape);
     PyMem_Free(pyobj->fBufInfo.strides);
-    if ((intptr_t)pyobj->fBufInfo.internal & CPyCppyy::LowLevelView::kIsOwner) {
-       if ((intptr_t)pyobj->fBufInfo.internal & CPyCppyy::LowLevelView::kIsCppArray)
+    if ((intptr_t)pyobj->fBufInfo.internal & cppjit::cpyrt::LowLevelView::kIsOwner) {
+       if ((intptr_t)pyobj->fBufInfo.internal & cppjit::cpyrt::LowLevelView::kIsCppArray)
            delete [] pyobj->fBuf;
        else
            free(pyobj->fBuf);
@@ -78,13 +78,13 @@ static void ll_dealloc(CPyCppyy::LowLevelView* pyobj)
 
 
 //----------------------------------------------------------------------------
-#define CPYCPPYY_LL_FLAG_GETSET(name, flag, doc)                             \
-static PyObject* ll_get##name(CPyCppyy::LowLevelView* pyobj)                 \
+#define CPYRT_LL_FLAG_GETSET(name, flag, doc)                             \
+static PyObject* ll_get##name(cppjit::cpyrt::LowLevelView* pyobj)                 \
 {                                                                            \
     return PyBool_FromLong((long)((intptr_t)pyobj->fBufInfo.internal & flag));\
 }                                                                            \
                                                                              \
-static int ll_set##name(CPyCppyy::LowLevelView* pyobj, PyObject* value, void*)\
+static int ll_set##name(cppjit::cpyrt::LowLevelView* pyobj, PyObject* value, void*)\
 {                                                                            \
     long settrue = PyLong_AsLong(value);                                     \
     if (settrue == -1 && PyErr_Occurred()) {                                 \
@@ -100,13 +100,13 @@ static int ll_set##name(CPyCppyy::LowLevelView* pyobj, PyObject* value, void*)\
     return 0;                                                                \
 }
 
-CPYCPPYY_LL_FLAG_GETSET(ownership, CPyCppyy::LowLevelView::kIsOwner,    __python_owns__)
-CPYCPPYY_LL_FLAG_GETSET(cpparray,  CPyCppyy::LowLevelView::kIsCppArray, __cpp_array__)
+CPYRT_LL_FLAG_GETSET(ownership, cppjit::cpyrt::LowLevelView::kIsOwner,    __python_owns__)
+CPYRT_LL_FLAG_GETSET(cpparray,  cppjit::cpyrt::LowLevelView::kIsCppArray, __cpp_array__)
 
 //---------------------------------------------------------------------------
-static PyObject* ll_typecode(CPyCppyy::LowLevelView* self, void*)
+static PyObject* ll_typecode(cppjit::cpyrt::LowLevelView* self, void*)
 {
-    return CPyCppyy_PyText_FromString((char*)self->fBufInfo.format);
+    return cpyrt_PyText_FromString((char*)self->fBufInfo.format);
 }
 
 
@@ -243,7 +243,7 @@ static char* lookup_dimension(Py_buffer& view, char* ptr, int dim, Py_ssize_t in
 
     nitems = view.shape[dim];
     if (index < 0) {
-        if (nitems != CPyCppyy::UNKNOWN_SIZE)
+        if (nitems != cppjit::cpyrt::UNKNOWN_SIZE)
             index += nitems;
         else {
             PyErr_Format(PyExc_IndexError,
@@ -252,13 +252,13 @@ static char* lookup_dimension(Py_buffer& view, char* ptr, int dim, Py_ssize_t in
         }
     }
 
-    if (view.strides[dim] == CPyCppyy::UNKNOWN_SIZE) {
+    if (view.strides[dim] == cppjit::cpyrt::UNKNOWN_SIZE) {
         PyErr_Format(PyExc_IndexError,
             "multi index not supported on dimension %d with unknown stride", dim + 1);
         return nullptr;
     }
 
-    if (nitems != CPyCppyy::UNKNOWN_SIZE && (index < 0 || index >= nitems)) {
+    if (nitems != cppjit::cpyrt::UNKNOWN_SIZE && (index < 0 || index >= nitems)) {
         PyErr_Format(PyExc_IndexError,
             "index out of bounds on dimension %d", dim + 1);
         return nullptr;
@@ -272,7 +272,7 @@ static char* lookup_dimension(Py_buffer& view, char* ptr, int dim, Py_ssize_t in
 
 // Get the pointer to the item at index.
 //---------------------------------------------------------------------------
-static inline void* ptr_from_index(CPyCppyy::LowLevelView* llview, Py_ssize_t index)
+static inline void* ptr_from_index(cppjit::cpyrt::LowLevelView* llview, Py_ssize_t index)
 {
     Py_buffer& view = llview->fBufInfo;
     return lookup_dimension(view, (char*)llview->get_buf(), 0, index);
@@ -280,7 +280,7 @@ static inline void* ptr_from_index(CPyCppyy::LowLevelView* llview, Py_ssize_t in
 
 // Get the pointer to the item at tuple.
 //---------------------------------------------------------------------------
-static void* ptr_from_tuple(CPyCppyy::LowLevelView* llview, PyObject* tup)
+static void* ptr_from_tuple(cppjit::cpyrt::LowLevelView* llview, PyObject* tup)
 {
     Py_buffer& view = llview->fBufInfo;
 
@@ -303,7 +303,7 @@ static void* ptr_from_tuple(CPyCppyy::LowLevelView* llview, PyObject* tup)
         if (!ptr)
             return nullptr;
 
-        if (!((intptr_t)view.internal & CPyCppyy::LowLevelView::kIsFixed) && dim != view.ndim-1)
+        if (!((intptr_t)view.internal & cppjit::cpyrt::LowLevelView::kIsFixed) && dim != view.ndim-1)
             ptr = *(char**)ptr;
     }
     return ptr;
@@ -311,7 +311,7 @@ static void* ptr_from_tuple(CPyCppyy::LowLevelView* llview, PyObject* tup)
 
 
 //= mapping methods =========================================================
-static Py_ssize_t ll_length(CPyCppyy::LowLevelView* self)
+static Py_ssize_t ll_length(cppjit::cpyrt::LowLevelView* self)
 {
     if (!self->get_buf())
         return 0;
@@ -384,7 +384,7 @@ static Py_ssize_t is_multiindex(PyObject* key)
 // with the type specified by view->format. Otherwise, the item is a sub-view.
 // The function is used in ll_subscript() and ll_as_sequence.
 //---------------------------------------------------------------------------
-static PyObject* ll_item(CPyCppyy::LowLevelView* self, Py_ssize_t index)
+static PyObject* ll_item(cppjit::cpyrt::LowLevelView* self, Py_ssize_t index)
 {
     Py_buffer& view = self->fBufInfo;
 
@@ -400,7 +400,7 @@ static PyObject* ll_item(CPyCppyy::LowLevelView* self, Py_ssize_t index)
 
     void* ptr = ptr_from_index(self, index);
     if (ptr) {
-        bool isfix = (intptr_t)view.internal & CPyCppyy::LowLevelView::kIsFixed;
+        bool isfix = (intptr_t)view.internal & cppjit::cpyrt::LowLevelView::kIsFixed;
         if (self->fBufInfo.ndim == 1 || !isfix)
             return self->fConverter->FromMemory(ptr);
         return self->fConverter->FromMemory((void*)&ptr);
@@ -411,7 +411,7 @@ static PyObject* ll_item(CPyCppyy::LowLevelView* self, Py_ssize_t index)
 
 // Return the item at position *key* (a tuple of indices).
 //---------------------------------------------------------------------------
-static PyObject* ll_item_multi(CPyCppyy::LowLevelView* self, PyObject *tup)
+static PyObject* ll_item_multi(cppjit::cpyrt::LowLevelView* self, PyObject *tup)
 {
     Py_buffer& view = self->fBufInfo;
     Py_ssize_t nindices = PyTuple_GET_SIZE(tup);
@@ -437,7 +437,7 @@ static PyObject* ll_item_multi(CPyCppyy::LowLevelView* self, PyObject *tup)
 // 0-d lowlevelptr objects can be referenced using llp[...] or llp[()]
 // but not with anything else.
 //---------------------------------------------------------------------------
-static PyObject* ll_subscript(CPyCppyy::LowLevelView* self, PyObject* key)
+static PyObject* ll_subscript(cppjit::cpyrt::LowLevelView* self, PyObject* key)
 {
     Py_buffer& view = self->fBufInfo;
 
@@ -480,11 +480,11 @@ static PyObject* ll_subscript(CPyCppyy::LowLevelView* self, PyObject* key)
                     slice_buf[i*isize+j] = buf[(start+cur)*isize + j];
             }
 
-            CPyCppyy::LowLevelView* ll = self->fCreator(slice_buf, {1, slicelen});
+            cppjit::cpyrt::LowLevelView* ll = self->fCreator(slice_buf, {1, slicelen});
             if (!ll)
                 delete [] slice_buf;
             else
-                (intptr_t&)ll->fBufInfo.internal |= CPyCppyy::LowLevelView::kIsOwner;
+                (intptr_t&)ll->fBufInfo.internal |= cppjit::cpyrt::LowLevelView::kIsOwner;
 
             return (PyObject*)ll;
 
@@ -510,7 +510,7 @@ static PyObject* ll_subscript(CPyCppyy::LowLevelView* self, PyObject* key)
 }
 
 //---------------------------------------------------------------------------
-static int ll_ass_sub(CPyCppyy::LowLevelView* self, PyObject* key, PyObject* value)
+static int ll_ass_sub(cppjit::cpyrt::LowLevelView* self, PyObject* key, PyObject* value)
 {
     Py_buffer& view = self->fBufInfo;
     Py_buffer src;
@@ -607,7 +607,7 @@ static int ll_ass_sub(CPyCppyy::LowLevelView* self, PyObject* key, PyObject* val
 }
 
 //---------------------------------------------------------------------------
-static int ll_getbuf(CPyCppyy::LowLevelView* self, Py_buffer* view, int flags)
+static int ll_getbuf(cppjit::cpyrt::LowLevelView* self, Py_buffer* view, int flags)
 {
 // Simplified from memoryobject, as we're always dealing with C arrays.
 
@@ -658,7 +658,7 @@ static PyObject* ll_iter(PyObject* self) {
 // default, except that it checks the size externally to raise StopIteration,
 // rather than geitem failing.
 
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
 
     indexiterobject* ii = PyObject_GC_New(indexiterobject, &IndexIter_Type);
     if (!ii) return nullptr;
@@ -703,7 +703,7 @@ static PyBufferProcs ll_as_buffer = {
 
 
 //---------------------------------------------------------------------------
-static PyObject* ll_shape(CPyCppyy::LowLevelView* self)
+static PyObject* ll_shape(cppjit::cpyrt::LowLevelView* self)
 {
     Py_buffer& view = self->fBufInfo;
 
@@ -715,7 +715,7 @@ static PyObject* ll_shape(CPyCppyy::LowLevelView* self)
 }
 
 //---------------------------------------------------------------------------
-static PyObject* ll_reshape(CPyCppyy::LowLevelView* self, PyObject* shape)
+static PyObject* ll_reshape(cppjit::cpyrt::LowLevelView* self, PyObject* shape)
 {
 // Allow the user to fix up the actual (type-strided) size of the buffer.
     if (!PyTuple_Check(shape)) {
@@ -723,7 +723,7 @@ static PyObject* ll_reshape(CPyCppyy::LowLevelView* self, PyObject* shape)
             PyObject* pystr = PyObject_Str(shape);
             if (pystr) {
                 PyErr_Format(PyExc_TypeError, "tuple object expected, received %s",
-                    CPyCppyy_PyText_AsStringChecked(pystr));
+                    cpyrt_PyText_AsStringChecked(pystr));
                 Py_DECREF(pystr);
                 return nullptr;
             }
@@ -738,7 +738,7 @@ static PyObject* ll_reshape(CPyCppyy::LowLevelView* self, PyObject* shape)
     Py_ssize_t oldsz = 0;
     for (Py_ssize_t idim = 0; idim < view.ndim; ++idim) {
         Py_ssize_t nlen = view.shape[idim];
-        if (nlen == CPyCppyy::UNKNOWN_SIZE || nlen == INT_MAX/view.itemsize /* fake 'max' */) {
+        if (nlen == cppjit::cpyrt::UNKNOWN_SIZE || nlen == INT_MAX/view.itemsize /* fake 'max' */) {
             oldsz = -1;      // meaning, unable to check size match
             break;
         }
@@ -752,7 +752,7 @@ static PyObject* ll_reshape(CPyCppyy::LowLevelView* self, PyObject* shape)
         if (oldsz != newsz) {
             PyObject* tas = PyObject_Str(shape);
             PyErr_Format(PyExc_ValueError,
-                "cannot reshape array of size %ld into shape %s", (long)oldsz, CPyCppyy_PyText_AsString(tas));
+                "cannot reshape array of size %ld into shape %s", (long)oldsz, cpyrt_PyText_AsString(tas));
             Py_DECREF(tas);
             return nullptr;
         }
@@ -786,7 +786,7 @@ static PyObject* ll_reshape(CPyCppyy::LowLevelView* self, PyObject* shape)
 
 
 //---------------------------------------------------------------------------
-static PyObject* ll_array(CPyCppyy::LowLevelView* self, PyObject* args, PyObject* kwds)
+static PyObject* ll_array(cppjit::cpyrt::LowLevelView* self, PyObject* args, PyObject* kwds)
 {
 // Construct a numpy array from the lowlevelview (w/o copy if possible); this
 // uses the Python methods to avoid depending on numpy directly
@@ -798,7 +798,7 @@ static PyObject* ll_array(CPyCppyy::LowLevelView* self, PyObject* args, PyObject
 
     bool docopy = false;
     if (kwds) {
-        PyObject* pycp = PyObject_GetItem(kwds, CPyCppyy::PyStrings::gCopy);
+        PyObject* pycp = PyObject_GetItem(kwds, cppjit::cpyrt::PyStrings::gCopy);
         if (!pycp) {
             PyErr_SetString(PyExc_TypeError, "__array__ only supports the \"copy\" keyword");
             return nullptr;
@@ -812,7 +812,7 @@ static PyObject* ll_array(CPyCppyy::LowLevelView* self, PyObject* args, PyObject
     // expect possible dtype from the arguments, otherwise take it from the type code
         PyObject* dtype;
         if (!args || PyTuple_GET_SIZE(args) != 1) {
-            PyObject* npdtype = PyObject_GetAttr(npmod, CPyCppyy::PyStrings::gDType);
+            PyObject* npdtype = PyObject_GetAttr(npmod, cppjit::cpyrt::PyStrings::gDType);
             PyObject* typecode = ll_typecode(self, nullptr);
             dtype = PyObject_CallFunctionObjArgs(npdtype, typecode, nullptr);
             Py_DECREF(typecode);
@@ -825,7 +825,7 @@ static PyObject* ll_array(CPyCppyy::LowLevelView* self, PyObject* args, PyObject
         if (!dtype)
             return nullptr;
 
-        PyObject* npfrombuf = PyObject_GetAttr(npmod, CPyCppyy::PyStrings::gFromBuffer);
+        PyObject* npfrombuf = PyObject_GetAttr(npmod, cppjit::cpyrt::PyStrings::gFromBuffer);
         PyObject* view = PyObject_CallFunctionObjArgs(npfrombuf, (PyObject*)self, dtype, nullptr);
         Py_DECREF(dtype);
         Py_DECREF(npfrombuf);
@@ -833,7 +833,7 @@ static PyObject* ll_array(CPyCppyy::LowLevelView* self, PyObject* args, PyObject
         return view;
 
     } else {                 // copy requested
-        PyObject* npcopy = PyObject_GetAttr(npmod, CPyCppyy::PyStrings::gCopy);
+        PyObject* npcopy = PyObject_GetAttr(npmod, cppjit::cpyrt::PyStrings::gCopy);
         PyObject* newarr = PyObject_CallFunctionObjArgs(npcopy, (PyObject*)self, nullptr);
         Py_DECREF(npcopy);
 
@@ -846,7 +846,7 @@ static PyObject* ll_array(CPyCppyy::LowLevelView* self, PyObject* args, PyObject
 
 
 //---------------------------------------------------------------------------
-static PyObject* ll_as_string(CPyCppyy::LowLevelView* self)
+static PyObject* ll_as_string(cppjit::cpyrt::LowLevelView* self)
 {
 // Interpret memory as a null-terminated char string.
     Py_buffer& view = self->fBufInfo;
@@ -860,7 +860,7 @@ static PyObject* ll_as_string(CPyCppyy::LowLevelView* self)
 
     char* buf = (char*)self->get_buf();
     size_t sz = strnlen(buf, (size_t)view.shape[0]);
-    return CPyCppyy_PyText_FromStringAndSize(buf, sz);
+    return cpyrt_PyText_FromStringAndSize(buf, sz);
 }
 
 //---------------------------------------------------------------------------
@@ -887,13 +887,13 @@ static PyGetSetDef ll_getset[] = {
 };
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
-//= CPyCppyy low level view type ============================================
+//= cpyrt low level view type ============================================
 PyTypeObject LowLevelView_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.LowLevelView",   // tp_name
-    sizeof(CPyCppyy::LowLevelView),// tp_basicsize
+    (char*)"cppjit.LowLevelView",   // tp_name
+    sizeof(cppjit::cpyrt::LowLevelView),// tp_basicsize
     0,                             // tp_itemsize
     (destructor)ll_dealloc,        // tp_dealloc
     0,                             // tp_vectorcall_offset / tp_print
@@ -941,10 +941,10 @@ PyTypeObject LowLevelView_Type = {
     0,                             // tp_version_tag
     0,                             // tp_finalize
     0                              // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 namespace {
 
@@ -998,7 +998,7 @@ template<> struct typecode_traits<std::complex<long>> {
 
 
 //---------------------------------------------------------------------------
-bool CPyCppyy::LowLevelView::resize(size_t sz)
+bool cppjit::cpyrt::LowLevelView::resize(size_t sz)
 {
     Py_buffer& bi = this->fBufInfo;
     if (bi.ndim == 1 && bi.shape) {
@@ -1012,10 +1012,10 @@ bool CPyCppyy::LowLevelView::resize(size_t sz)
 
 //---------------------------------------------------------------------------
 template<typename T>
-static inline CPyCppyy::LowLevelView* CreateLowLevelViewT(
-    T* address, CPyCppyy::cdims_t shape, const char* format = nullptr, const char* name = nullptr, Py_ssize_t itemsize = -1)
+static inline cppjit::cpyrt::LowLevelView* CreateLowLevelViewT(
+    T* address, cppjit::cpyrt::cdims_t shape, const char* format = nullptr, const char* name = nullptr, Py_ssize_t itemsize = -1)
 {
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
     Py_ssize_t nx = (shape.ndim() != UNKNOWN_SIZE) ? shape[0] : INT_MAX/sizeof(T);
     if (nx == UNKNOWN_SIZE) nx = INT_MAX/sizeof(T);
     PyObject* args = PyTuple_New(0);
@@ -1033,12 +1033,12 @@ static inline CPyCppyy::LowLevelView* CreateLowLevelViewT(
     view.shape[0]       = nx;      // view.len / view.itemsize
     view.strides        = (Py_ssize_t*)PyMem_Malloc(view.ndim * sizeof(Py_ssize_t));
     view.suboffsets     = nullptr;
-    (intptr_t&)view.internal = CPyCppyy::LowLevelView::kIsCppArray;  // assumed
+    (intptr_t&)view.internal = cppjit::cpyrt::LowLevelView::kIsCppArray;  // assumed
     bool isfix = shape.ndim() != UNKNOWN_SIZE;
     if (isfix) {
         for (int i = 0; i < shape.ndim(); ++i)
            isfix = isfix && (shape[i] != UNKNOWN_SIZE);
-        if (isfix) (intptr_t&)view.internal |= CPyCppyy::LowLevelView::kIsFixed;
+        if (isfix) (intptr_t&)view.internal |= cppjit::cpyrt::LowLevelView::kIsFixed;
     }
 
     llp->fElemCnv = CreateConverter(name ? name : typecode_traits<T>::name);
@@ -1069,87 +1069,87 @@ static inline CPyCppyy::LowLevelView* CreateLowLevelViewT(
 
 //---------------------------------------------------------------------------
 template<typename T>
-static inline CPyCppyy::LowLevelView* CreateLowLevelViewT(
-    T** address, CPyCppyy::cdims_t shape, const char* format = nullptr, const char* name = nullptr)
+static inline cppjit::cpyrt::LowLevelView* CreateLowLevelViewT(
+    T** address, cppjit::cpyrt::cdims_t shape, const char* format = nullptr, const char* name = nullptr)
 {
-    using namespace CPyCppyy;
+    using namespace cppjit::cpyrt;
     LowLevelView* llp = (LowLevelView*)CreateLowLevelViewT((T*)address, shape, format, name);
     llp->set_buf((void**)address);
     return llp;
 }
 
 //---------------------------------------------------------------------------
-#define CPPYY_RET_W_CREATOR(type, fname)                                    \
+#define CPPJIT_RET_W_CREATOR(type, fname)                                    \
     PyObject* (*c)(type, cdims_t) = &fname;                                 \
     ll->fCreator = (LowLevelView::Creator_t)c;                              \
     return (PyObject*)ll
 
-#define CPPYY_IMPL_VIEW_CREATOR(type)                                       \
-PyObject* CPyCppyy::CreateLowLevelView(type* address, cdims_t shape) {      \
+#define CPPJIT_IMPL_VIEW_CREATOR(type)                                       \
+PyObject* cppjit::cpyrt::CreateLowLevelView(type* address, cdims_t shape) {      \
     LowLevelView* ll = CreateLowLevelViewT<type>(address, shape);           \
-    CPPYY_RET_W_CREATOR(type*, CreateLowLevelView);                         \
+    CPPJIT_RET_W_CREATOR(type*, CreateLowLevelView);                         \
 }                                                                           \
-PyObject* CPyCppyy::CreateLowLevelView(type** address, cdims_t shape) {     \
+PyObject* cppjit::cpyrt::CreateLowLevelView(type** address, cdims_t shape) {     \
     LowLevelView* ll = CreateLowLevelViewT<type>(address, shape);           \
-    CPPYY_RET_W_CREATOR(type**, CreateLowLevelView);                        \
+    CPPJIT_RET_W_CREATOR(type**, CreateLowLevelView);                        \
 }
 
-CPPYY_IMPL_VIEW_CREATOR(bool);
-CPPYY_IMPL_VIEW_CREATOR(signed char);
-CPPYY_IMPL_VIEW_CREATOR(unsigned char);
-CPPYY_IMPL_VIEW_CREATOR(std::byte);
-CPPYY_IMPL_VIEW_CREATOR(short);
-CPPYY_IMPL_VIEW_CREATOR(unsigned short);
-CPPYY_IMPL_VIEW_CREATOR(int);
-CPPYY_IMPL_VIEW_CREATOR(unsigned int);
-CPPYY_IMPL_VIEW_CREATOR(long);
-CPPYY_IMPL_VIEW_CREATOR(unsigned long);
-CPPYY_IMPL_VIEW_CREATOR(long long);
-CPPYY_IMPL_VIEW_CREATOR(unsigned long long);
-CPPYY_IMPL_VIEW_CREATOR(float);
-CPPYY_IMPL_VIEW_CREATOR(double);
-CPPYY_IMPL_VIEW_CREATOR(long double);
-CPPYY_IMPL_VIEW_CREATOR(std::complex<float>);
-CPPYY_IMPL_VIEW_CREATOR(std::complex<double>);
-CPPYY_IMPL_VIEW_CREATOR(std::complex<int>);
-CPPYY_IMPL_VIEW_CREATOR(std::complex<long>);
-
-PyObject* CPyCppyy::CreateLowLevelView(char* address, cdims_t shape) {
+CPPJIT_IMPL_VIEW_CREATOR(bool);
+CPPJIT_IMPL_VIEW_CREATOR(signed char);
+CPPJIT_IMPL_VIEW_CREATOR(unsigned char);
+CPPJIT_IMPL_VIEW_CREATOR(std::byte);
+CPPJIT_IMPL_VIEW_CREATOR(short);
+CPPJIT_IMPL_VIEW_CREATOR(unsigned short);
+CPPJIT_IMPL_VIEW_CREATOR(int);
+CPPJIT_IMPL_VIEW_CREATOR(unsigned int);
+CPPJIT_IMPL_VIEW_CREATOR(long);
+CPPJIT_IMPL_VIEW_CREATOR(unsigned long);
+CPPJIT_IMPL_VIEW_CREATOR(long long);
+CPPJIT_IMPL_VIEW_CREATOR(unsigned long long);
+CPPJIT_IMPL_VIEW_CREATOR(float);
+CPPJIT_IMPL_VIEW_CREATOR(double);
+CPPJIT_IMPL_VIEW_CREATOR(long double);
+CPPJIT_IMPL_VIEW_CREATOR(std::complex<float>);
+CPPJIT_IMPL_VIEW_CREATOR(std::complex<double>);
+CPPJIT_IMPL_VIEW_CREATOR(std::complex<int>);
+CPPJIT_IMPL_VIEW_CREATOR(std::complex<long>);
+
+PyObject* cppjit::cpyrt::CreateLowLevelView(char* address, cdims_t shape) {
     LowLevelView* ll = CreateLowLevelViewT<char>(address, shape);
-    CPPYY_RET_W_CREATOR(char*, CreateLowLevelView);
+    CPPJIT_RET_W_CREATOR(char*, CreateLowLevelView);
 }
 
-PyObject* CPyCppyy::CreateLowLevelView(char** address, cdims_t shape) {
+PyObject* cppjit::cpyrt::CreateLowLevelView(char** address, cdims_t shape) {
     LowLevelView* ll = CreateLowLevelViewT<char>(address, shape);
-    CPPYY_RET_W_CREATOR(char**, CreateLowLevelView);
+    CPPJIT_RET_W_CREATOR(char**, CreateLowLevelView);
 }
 
-PyObject* CPyCppyy::CreateLowLevelViewString(char** address, cdims_t shape) {
+PyObject* cppjit::cpyrt::CreateLowLevelViewString(char** address, cdims_t shape) {
     LowLevelView* ll = CreateLowLevelViewT<char*>(address, shape, nullptr, nullptr, sizeof(char));
-    CPPYY_RET_W_CREATOR(char**, CreateLowLevelViewString);
+    CPPJIT_RET_W_CREATOR(char**, CreateLowLevelViewString);
 }
 
-PyObject* CPyCppyy::CreateLowLevelViewString(const char** address, cdims_t shape) {
+PyObject* cppjit::cpyrt::CreateLowLevelViewString(const char** address, cdims_t shape) {
     LowLevelView* ll = CreateLowLevelViewT<const char*>(address, shape, nullptr, nullptr, sizeof(char));
-    CPPYY_RET_W_CREATOR(const char**, CreateLowLevelViewString);
+    CPPJIT_RET_W_CREATOR(const char**, CreateLowLevelViewString);
 }
 
-PyObject* CPyCppyy::CreateLowLevelView_i8(int8_t* address,  cdims_t shape) {
+PyObject* cppjit::cpyrt::CreateLowLevelView_i8(int8_t* address,  cdims_t shape) {
     LowLevelView* ll = CreateLowLevelViewT<int8_t>(address, shape, "b", "int8_t");
-    CPPYY_RET_W_CREATOR(int8_t*, CreateLowLevelView_i8);
+    CPPJIT_RET_W_CREATOR(int8_t*, CreateLowLevelView_i8);
 }
 
-PyObject* CPyCppyy::CreateLowLevelView_i8(int8_t** address, cdims_t shape) {
+PyObject* cppjit::cpyrt::CreateLowLevelView_i8(int8_t** address, cdims_t shape) {
     LowLevelView* ll = CreateLowLevelViewT<int8_t>(address, shape, "b", "int8_t");
-    CPPYY_RET_W_CREATOR(int8_t**, CreateLowLevelView_i8);
+    CPPJIT_RET_W_CREATOR(int8_t**, CreateLowLevelView_i8);
 }
 
-PyObject* CPyCppyy::CreateLowLevelView_i8(uint8_t* address,  cdims_t shape) {
+PyObject* cppjit::cpyrt::CreateLowLevelView_i8(uint8_t* address,  cdims_t shape) {
     LowLevelView* ll = CreateLowLevelViewT<uint8_t>(address, shape, "B", "uint8_t");
-    CPPYY_RET_W_CREATOR(uint8_t*, CreateLowLevelView_i8);
+    CPPJIT_RET_W_CREATOR(uint8_t*, CreateLowLevelView_i8);
 }
 
-PyObject* CPyCppyy::CreateLowLevelView_i8(uint8_t** address, cdims_t shape) {
+PyObject* cppjit::cpyrt::CreateLowLevelView_i8(uint8_t** address, cdims_t shape) {
     LowLevelView* ll = CreateLowLevelViewT<uint8_t>(address, shape, "B", "uint8_t");
-    CPPYY_RET_W_CREATOR(uint8_t**, CreateLowLevelView_i8);
+    CPPJIT_RET_W_CREATOR(uint8_t**, CreateLowLevelView_i8);
 }
diff --git a/src/CPyCppyy/src/LowLevelViews.h b/src/cpyrt/LowLevelViews.h
similarity index 64%
rename from src/CPyCppyy/src/LowLevelViews.h
rename to src/cpyrt/LowLevelViews.h
index 0edb329..e59ddea 100644
--- a/src/CPyCppyy/src/LowLevelViews.h
+++ b/src/cpyrt/LowLevelViews.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_LOWLEVELVIEWS_H
-#define CPYCPPYY_LOWLEVELVIEWS_H
+#ifndef CPYRT_LOWLEVELVIEWS_H
+#define CPYRT_LOWLEVELVIEWS_H
 
 // Bindings
 #include "Dimensions.h"
@@ -10,7 +10,7 @@
 #include <cstddef>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class Converter;
 
@@ -39,34 +39,34 @@ class LowLevelView {
     bool resize(size_t sz);
 };
 
-#define CPPYY_DECL_VIEW_CREATOR(type)                                        \
+#define CPPJIT_DECL_VIEW_CREATOR(type)                                        \
     PyObject* CreateLowLevelView(type*,  cdims_t shape);                     \
     PyObject* CreateLowLevelView(type**, cdims_t shape)
 
-CPPYY_DECL_VIEW_CREATOR(bool);
-CPPYY_DECL_VIEW_CREATOR(char);
-CPPYY_DECL_VIEW_CREATOR(signed char);
-CPPYY_DECL_VIEW_CREATOR(unsigned char);
-CPPYY_DECL_VIEW_CREATOR(std::byte);
+CPPJIT_DECL_VIEW_CREATOR(bool);
+CPPJIT_DECL_VIEW_CREATOR(char);
+CPPJIT_DECL_VIEW_CREATOR(signed char);
+CPPJIT_DECL_VIEW_CREATOR(unsigned char);
+CPPJIT_DECL_VIEW_CREATOR(std::byte);
 PyObject* CreateLowLevelView_i8(int8_t*,  cdims_t shape);
 PyObject* CreateLowLevelView_i8(int8_t**, cdims_t shape);
 PyObject* CreateLowLevelView_i8(uint8_t*,  cdims_t shape);
 PyObject* CreateLowLevelView_i8(uint8_t**, cdims_t shape);
-CPPYY_DECL_VIEW_CREATOR(short);
-CPPYY_DECL_VIEW_CREATOR(unsigned short);
-CPPYY_DECL_VIEW_CREATOR(int);
-CPPYY_DECL_VIEW_CREATOR(unsigned int);
-CPPYY_DECL_VIEW_CREATOR(long);
-CPPYY_DECL_VIEW_CREATOR(unsigned long);
-CPPYY_DECL_VIEW_CREATOR(long long);
-CPPYY_DECL_VIEW_CREATOR(unsigned long long);
-CPPYY_DECL_VIEW_CREATOR(float);
-CPPYY_DECL_VIEW_CREATOR(double);
-CPPYY_DECL_VIEW_CREATOR(long double);
-CPPYY_DECL_VIEW_CREATOR(std::complex<float>);
-CPPYY_DECL_VIEW_CREATOR(std::complex<double>);
-CPPYY_DECL_VIEW_CREATOR(std::complex<int>);
-CPPYY_DECL_VIEW_CREATOR(std::complex<long>);
+CPPJIT_DECL_VIEW_CREATOR(short);
+CPPJIT_DECL_VIEW_CREATOR(unsigned short);
+CPPJIT_DECL_VIEW_CREATOR(int);
+CPPJIT_DECL_VIEW_CREATOR(unsigned int);
+CPPJIT_DECL_VIEW_CREATOR(long);
+CPPJIT_DECL_VIEW_CREATOR(unsigned long);
+CPPJIT_DECL_VIEW_CREATOR(long long);
+CPPJIT_DECL_VIEW_CREATOR(unsigned long long);
+CPPJIT_DECL_VIEW_CREATOR(float);
+CPPJIT_DECL_VIEW_CREATOR(double);
+CPPJIT_DECL_VIEW_CREATOR(long double);
+CPPJIT_DECL_VIEW_CREATOR(std::complex<float>);
+CPPJIT_DECL_VIEW_CREATOR(std::complex<double>);
+CPPJIT_DECL_VIEW_CREATOR(std::complex<int>);
+CPPJIT_DECL_VIEW_CREATOR(std::complex<long>);
 
 PyObject* CreateLowLevelViewString(char**, cdims_t shape);
 PyObject* CreateLowLevelViewString(const char**, cdims_t shape);
@@ -90,6 +90,6 @@ inline bool LowLevelView_CheckExact(T* object)
     return object && Py_TYPE(object) == &LowLevelView_Type;
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_LOWLEVELVIEWS_H
+#endif // !CPYRT_LOWLEVELVIEWS_H
diff --git a/src/CPyCppyy/src/MemoryRegulator.cxx b/src/cpyrt/MemoryRegulator.cxx
similarity index 68%
rename from src/CPyCppyy/src/MemoryRegulator.cxx
rename to src/cpyrt/MemoryRegulator.cxx
index 4b6d22f..9255c88 100644
--- a/src/CPyCppyy/src/MemoryRegulator.cxx
+++ b/src/cpyrt/MemoryRegulator.cxx
@@ -1,6 +1,6 @@
 // Bindings
-#include "Cppyy.h"
-#include "CPyCppyy.h"
+#include "cppjit_interop.h"
+#include "cpyrt.h"
 #include "MemoryRegulator.h"
 #include "CPPInstance.h"
 #include "ProxyWrappers.h"
@@ -12,7 +12,7 @@
 
 
 //= pseudo-None type for masking out objects on the python side ===============
-static PyTypeObject CPyCppyy_NoneType;
+static PyTypeObject cpyrt_NoneType;
 
 //-----------------------------------------------------------------------------
 static Py_ssize_t AlwaysNullLength(PyObject*)
@@ -21,7 +21,7 @@ static Py_ssize_t AlwaysNullLength(PyObject*)
 }
 
 //-----------------------------------------------------------------------------
-static PyMappingMethods CPyCppyy_NoneType_mapping = {
+static PyMappingMethods cpyrt_NoneType_mapping = {
     AlwaysNullLength,
     (binaryfunc)              0,
     (objobjargproc)           0
@@ -36,28 +36,28 @@ static PyMappingMethods CPyCppyy_NoneType_mapping = {
 //-----------------------------------------------------------------------------
 namespace {
 
-struct InitCPyCppyy_NoneType_t {
-    InitCPyCppyy_NoneType_t() {
-    // create a CPyCppyy NoneType (for references that went dodo) from NoneType
-        memset(&CPyCppyy_NoneType, 0, sizeof(CPyCppyy_NoneType));
+struct Initcpyrt_NoneType_t {
+    Initcpyrt_NoneType_t() {
+    // create a cpyrt NoneType (for references that went dodo) from NoneType
+        memset(&cpyrt_NoneType, 0, sizeof(cpyrt_NoneType));
 
-        ((PyObject&)CPyCppyy_NoneType).ob_type    = &PyType_Type;
-        Py_SET_REFCNT((PyObject*)&CPyCppyy_NoneType, 1);
-        ((PyVarObject&)CPyCppyy_NoneType).ob_size = 0;
+        ((PyObject&)cpyrt_NoneType).ob_type    = &PyType_Type;
+        Py_SET_REFCNT((PyObject*)&cpyrt_NoneType, 1);
+        ((PyVarObject&)cpyrt_NoneType).ob_size = 0;
 
-        CPyCppyy_NoneType.tp_name        = const_cast<char*>("CPyCppyy_NoneType");
-        CPyCppyy_NoneType.tp_flags       = Py_TPFLAGS_HAVE_RICHCOMPARE;
+        cpyrt_NoneType.tp_name        = const_cast<char*>("cpyrt_NoneType");
+        cpyrt_NoneType.tp_flags       = Py_TPFLAGS_HAVE_RICHCOMPARE;
 
-        CPyCppyy_NoneType.tp_traverse    = (traverseproc)0;
-        CPyCppyy_NoneType.tp_clear       = (inquiry)0;
-        CPyCppyy_NoneType.tp_dealloc     = (destructor)&InitCPyCppyy_NoneType_t::DeAlloc;
-        CPyCppyy_NoneType.tp_repr        = Py_TYPE(Py_None)->tp_repr;
-        CPyCppyy_NoneType.tp_richcompare = (richcmpfunc)&InitCPyCppyy_NoneType_t::RichCompare;
-        CPyCppyy_NoneType.tp_hash        = (hashfunc)&InitCPyCppyy_NoneType_t::PtrHash;
+        cpyrt_NoneType.tp_traverse    = (traverseproc)0;
+        cpyrt_NoneType.tp_clear       = (inquiry)0;
+        cpyrt_NoneType.tp_dealloc     = (destructor)&Initcpyrt_NoneType_t::DeAlloc;
+        cpyrt_NoneType.tp_repr        = Py_TYPE(Py_None)->tp_repr;
+        cpyrt_NoneType.tp_richcompare = (richcmpfunc)&Initcpyrt_NoneType_t::RichCompare;
+        cpyrt_NoneType.tp_hash        = (hashfunc)&Initcpyrt_NoneType_t::PtrHash;
 
-        CPyCppyy_NoneType.tp_as_mapping  = &CPyCppyy_NoneType_mapping;
+        cpyrt_NoneType.tp_as_mapping  = &cpyrt_NoneType_mapping;
 
-        PyType_Ready(&CPyCppyy_NoneType);
+        PyType_Ready(&cpyrt_NoneType);
     }
 
     static void DeAlloc(PyObject* pyobj) { Py_TYPE(pyobj)->tp_free(pyobj); }
@@ -76,21 +76,21 @@ struct InitCPyCppyy_NoneType_t {
 } // unnamed namespace
 
 // Memory regulation hooks
-CPyCppyy::MemHook_t CPyCppyy::MemoryRegulator::registerHook   = nullptr;
-CPyCppyy::MemHook_t CPyCppyy::MemoryRegulator::unregisterHook = nullptr;
+cppjit::cpyrt::MemHook_t cppjit::cpyrt::MemoryRegulator::registerHook   = nullptr;
+cppjit::cpyrt::MemHook_t cppjit::cpyrt::MemoryRegulator::unregisterHook = nullptr;
 
 
 //- ctor/dtor ----------------------------------------------------------------
-CPyCppyy::MemoryRegulator::MemoryRegulator()
+cppjit::cpyrt::MemoryRegulator::MemoryRegulator()
 {
 // setup NoneType for referencing and create weakref cache
-    static InitCPyCppyy_NoneType_t initCPyCppyy_NoneType;
+    static Initcpyrt_NoneType_t initcpyrt_NoneType;
 }
 
 
 //- public members -----------------------------------------------------------
-bool CPyCppyy::MemoryRegulator::RecursiveRemove(
-    Cppyy::TCppObject_t cppobj, Cppyy::TCppScope_t klass)
+bool cppjit::cpyrt::MemoryRegulator::RecursiveRemove(
+    cppjit::interop::TCppObject_t cppobj, cppjit::interop::TCppScope_t klass)
 {
 // if registered by the framework, called whenever a cppobj gets destroyed
     if (!cppobj)
@@ -120,18 +120,18 @@ bool CPyCppyy::MemoryRegulator::RecursiveRemove(
         cppobjs->erase(ppo);
 
     // nullify the object
-        if (!CPyCppyy_NoneType.tp_traverse) {
+        if (!cpyrt_NoneType.tp_traverse) {
         // take a reference as we're copying its function pointers
             Py_INCREF(Py_TYPE(pyobj));
 
         // all object that arrive here are expected to be of the same type ("instance")
-            CPyCppyy_NoneType.tp_traverse   = Py_TYPE(pyobj)->tp_traverse;
-            CPyCppyy_NoneType.tp_clear      = Py_TYPE(pyobj)->tp_clear;
-            CPyCppyy_NoneType.tp_free       = Py_TYPE(pyobj)->tp_free;
-            CPyCppyy_NoneType.tp_flags     |= Py_TYPE(pyobj)->tp_flags;
-        } else if (CPyCppyy_NoneType.tp_traverse != Py_TYPE(pyobj)->tp_traverse) {
+            cpyrt_NoneType.tp_traverse   = Py_TYPE(pyobj)->tp_traverse;
+            cpyrt_NoneType.tp_clear      = Py_TYPE(pyobj)->tp_clear;
+            cpyrt_NoneType.tp_free       = Py_TYPE(pyobj)->tp_free;
+            cpyrt_NoneType.tp_flags     |= Py_TYPE(pyobj)->tp_flags;
+        } else if (cpyrt_NoneType.tp_traverse != Py_TYPE(pyobj)->tp_traverse) {
         // TODO: SystemError?
-            std::cerr << "in CPyCppyy::MemoryRegulater, unexpected object of type: "
+            std::cerr << "in cppjit::cpyrt::MemoryRegulater, unexpected object of type: "
                       << Py_TYPE(pyobj)->tp_name << std::endl;
 
         // drop object and leave before too much damage is done
@@ -150,9 +150,9 @@ bool CPyCppyy::MemoryRegulator::RecursiveRemove(
         op_dealloc_nofree(pyobj);      // normal object cleanup, while keeping memory
 
     // reset type object
-        Py_INCREF((PyObject*)(void*)&CPyCppyy_NoneType);
+        Py_INCREF((PyObject*)(void*)&cpyrt_NoneType);
         Py_DECREF(Py_TYPE(pyobj));
-        ((PyObject*)pyobj)->ob_type = &CPyCppyy_NoneType;
+        ((PyObject*)pyobj)->ob_type = &cpyrt_NoneType;
 
         Py_DECREF(pyscope);
         return true;
@@ -164,8 +164,8 @@ bool CPyCppyy::MemoryRegulator::RecursiveRemove(
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::MemoryRegulator::RegisterPyObject(
-    CPPInstance* pyobj, Cppyy::TCppObject_t cppobj)
+bool cppjit::cpyrt::MemoryRegulator::RegisterPyObject(
+    CPPInstance* pyobj, cppjit::interop::TCppObject_t cppobj)
 {
 // start tracking <cppobj> proxied by <pyobj>
     if (!(pyobj && cppobj))
@@ -193,13 +193,13 @@ bool CPyCppyy::MemoryRegulator::RegisterPyObject(
 }
 
 //-----------------------------------------------------------------------------
-bool CPyCppyy::MemoryRegulator::UnregisterPyObject(CPPInstance* pyobj, PyObject* pyclass)
+bool cppjit::cpyrt::MemoryRegulator::UnregisterPyObject(CPPInstance* pyobj, PyObject* pyclass)
 {
 // called when the proxy is garbage collected or is about delete the C++ instance
     if (!(pyobj && pyclass))
         return false;
 
-    Cppyy::TCppObject_t cppobj = pyobj->IsSmart() ? pyobj->GetObjectRaw() : pyobj->GetObject();
+    cppjit::interop::TCppObject_t cppobj = pyobj->IsSmart() ? pyobj->GetObjectRaw() : pyobj->GetObject();
     if (!cppobj)
         return false;
 
@@ -222,7 +222,7 @@ bool CPyCppyy::MemoryRegulator::UnregisterPyObject(CPPInstance* pyobj, PyObject*
 }
 
 //-----------------------------------------------------------------------------
-PyObject* CPyCppyy::MemoryRegulator::RetrievePyObject(Cppyy::TCppObject_t cppobj, PyObject* pyclass)
+PyObject* cppjit::cpyrt::MemoryRegulator::RetrievePyObject(cppjit::interop::TCppObject_t cppobj, PyObject* pyclass)
 {
 // lookup to see if a C++ address is already known, return old proxy if tracked
     if (!(cppobj && pyclass))
@@ -243,13 +243,13 @@ PyObject* CPyCppyy::MemoryRegulator::RetrievePyObject(Cppyy::TCppObject_t cppobj
 
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::MemoryRegulator::SetRegisterHook(MemHook_t h) {
+void cppjit::cpyrt::MemoryRegulator::SetRegisterHook(MemHook_t h) {
 // Set custom register hook; called when a regulated object is to be tracked
     registerHook = h;
 }
 
 //-----------------------------------------------------------------------------
-void CPyCppyy::MemoryRegulator::SetUnregisterHook(MemHook_t h) {
+void cppjit::cpyrt::MemoryRegulator::SetUnregisterHook(MemHook_t h) {
 // Set custom unregister hook; called when a regulated object is to be untracked
     unregisterHook = h;
 }
diff --git a/src/CPyCppyy/src/MemoryRegulator.h b/src/cpyrt/MemoryRegulator.h
similarity index 54%
rename from src/CPyCppyy/src/MemoryRegulator.h
rename to src/cpyrt/MemoryRegulator.h
index 6096f37..7f18f81 100644
--- a/src/CPyCppyy/src/MemoryRegulator.h
+++ b/src/cpyrt/MemoryRegulator.h
@@ -1,17 +1,17 @@
-#ifndef CPYCPPYY_MEMORYREGULATOR_H
-#define CPYCPPYY_MEMORYREGULATOR_H
+#ifndef CPYRT_MEMORYREGULATOR_H
+#define CPYRT_MEMORYREGULATOR_H
 
 #include "Python.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 
 #include <functional>
 #include <utility>
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class CPPInstance;
 
-typedef std::function<std::pair<bool, bool>(Cppyy::TCppObject_t, Cppyy::TCppScope_t)> MemHook_t;
+typedef std::function<std::pair<bool, bool>(cppjit::interop::TCppObject_t, cppjit::interop::TCppScope_t)> MemHook_t;
 
 class MemoryRegulator {
 private:
@@ -21,23 +21,23 @@ class MemoryRegulator {
     MemoryRegulator();
 
 // callback from C++-side frameworks
-    static bool RecursiveRemove(Cppyy::TCppObject_t cppobj, Cppyy::TCppScope_t klass);
+    static bool RecursiveRemove(cppjit::interop::TCppObject_t cppobj, cppjit::interop::TCppScope_t klass);
 
 // called when a new python proxy object is created
-    static bool RegisterPyObject(CPPInstance* pyobj, Cppyy::TCppObject_t cppobj);
+    static bool RegisterPyObject(CPPInstance* pyobj, cppjit::interop::TCppObject_t cppobj);
 
 // called when a the python proxy object is about to be garbage collected or when it is
 // about to delete the proxied C++ object, if owned
     static bool UnregisterPyObject(CPPInstance* pyobj, PyObject* pyclass);
 
 // new reference to python object matching cppobj, or 0 on failure
-    static PyObject* RetrievePyObject(Cppyy::TCppObject_t cppobj, PyObject* pyclass);
+    static PyObject* RetrievePyObject(cppjit::interop::TCppObject_t cppobj, PyObject* pyclass);
 
 // set hooks for custom memory regulation
     static void SetRegisterHook(MemHook_t h);
     static void SetUnregisterHook(MemHook_t h);
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_MEMORYREGULATOR_H
+#endif // !CPYRT_MEMORYREGULATOR_H
diff --git a/src/CPyCppyy/src/ProxyWrappers.cxx b/src/cpyrt/ProxyWrappers.cxx
similarity index 79%
rename from src/CPyCppyy/src/ProxyWrappers.cxx
rename to src/cpyrt/ProxyWrappers.cxx
index e03a4d2..85b6f17 100644
--- a/src/CPyCppyy/src/ProxyWrappers.cxx
+++ b/src/cpyrt/ProxyWrappers.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "ProxyWrappers.h"
 #include "CPPClassMethod.h"
 #include "CPPConstructor.h"
@@ -12,7 +12,7 @@
 #include "CPPOperator.h"
 #include "CPPOverload.h"
 #include "CPPScope.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "MemoryRegulator.h"
 #include "PyStrings.h"
 #include "Pythonize.h"
@@ -31,20 +31,20 @@
 
 
 //- data _______________________________________________________________________
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     extern PyObject* gThisModule;
     extern PyObject* gPyTypeMap;
-    extern std::unordered_set<Cppyy::TCppScope_t> gPinnedTypes;
+    extern std::unordered_set<cppjit::interop::TCppScope_t> gPinnedTypes;
 }
 
 // to prevent having to walk scopes, track python classes by C++ class
-typedef std::unordered_map<Cppyy::TCppScope_t, PyObject*> PyClassMap_t;
+typedef std::unordered_map<cppjit::interop::TCppScope_t, PyObject*> PyClassMap_t;
 static PyClassMap_t gPyClasses;
 
 
 //- helpers --------------------------------------------------------------------
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 typedef struct {
     PyObject_HEAD
@@ -52,7 +52,7 @@ typedef struct {
 } proxyobject;
 
 // helper for creating new C++ proxy python types
-static PyObject* CreateNewCppProxyClass(Cppyy::TCppScope_t klass, PyObject* pybases)
+static PyObject* CreateNewCppProxyClass(cppjit::interop::TCppScope_t klass, PyObject* pybases)
 {
 // Create a new python shadow class with the required hierarchy and meta-classes.
     PyObject* pymetabases = PyTuple_New(PyTuple_GET_SIZE(pybases));
@@ -62,7 +62,7 @@ static PyObject* CreateNewCppProxyClass(Cppyy::TCppScope_t klass, PyObject* pyba
         PyTuple_SET_ITEM(pymetabases, i, btype);
     }
 
-    std::string name = Cppyy::GetFinalName(klass);
+    std::string name = cppjit::interop::GetFinalName(klass);
 
 // create meta-class, add a dummy __module__ to pre-empt the default setting
     PyObject* args = Py_BuildValue((char*)"sO{}", (name+"_meta").c_str(), pymetabases);
@@ -91,10 +91,10 @@ static PyObject* CreateNewCppProxyClass(Cppyy::TCppScope_t klass, PyObject* pyba
 
 static inline
 void AddPropertyToClass(PyObject* pyclass,
-    Cppyy::TCppScope_t scope, Cppyy::TCppScope_t data)
+    cppjit::interop::TCppScope_t scope, cppjit::interop::TCppScope_t data)
 {
-    CPyCppyy::CPPDataMember* property = CPyCppyy::CPPDataMember_New(scope, data);
-    PyObject* pname = CPyCppyy_PyText_InternFromString(const_cast<char*>(property->GetName().c_str()));
+    cppjit::cpyrt::CPPDataMember* property = cppjit::cpyrt::CPPDataMember_New(scope, data);
+    PyObject* pname = cpyrt_PyText_InternFromString(const_cast<char*>(property->GetName().c_str()));
 
 // allow access at the instance level
     PyType_Type.tp_setattro(pyclass, pname, (PyObject*)property);
@@ -108,7 +108,7 @@ void AddPropertyToClass(PyObject* pyclass,
     }
 
 // allow access at the class level (always add after setting instance level)
-    if (Cppyy::IsStaticDatamember(data) || Cppyy::IsEnumConstant(data))
+    if (cppjit::interop::IsStaticDatamember(data) || cppjit::interop::IsEnumConstant(data))
         PyType_Type.tp_setattro((PyObject*)Py_TYPE(pyclass), pname, (PyObject*)property);
 
 // cleanup
@@ -119,7 +119,7 @@ void AddPropertyToClass(PyObject* pyclass,
 static inline
 void AddScopeToParent(PyObject* parent, const std::string& name, PyObject* newscope)
 {
-    PyObject* pyname = CPyCppyy_PyText_InternFromString((char*)name.c_str());
+    PyObject* pyname = cpyrt_PyText_InternFromString((char*)name.c_str());
     if (CPPScope_Check(parent)) PyType_Type.tp_setattro(parent, pyname, newscope);
     else PyObject_SetAttr(parent, pyname, newscope);
     Py_DECREF(pyname);
@@ -137,17 +137,17 @@ PyObject* GetAttrDirect(PyObject* pyclass, PyObject* pyname) {
     return nullptr;
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 
 //- public functions ---------------------------------------------------------
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 static inline void sync_templates(
     PyObject* pyclass, const std::string& mtCppName, const std::string& mtName)
 {
     PyObject* dct = PyObject_GetAttr(pyclass, PyStrings::gDict);
-    PyObject* pyname = CPyCppyy_PyText_FromString(const_cast<char*>(mtName.c_str()));
+    PyObject* pyname = cpyrt_PyText_FromString(const_cast<char*>(mtName.c_str()));
     PyObject* attr = PyObject_GetItem(dct, pyname);
     if (!attr) PyErr_Clear();
     Py_DECREF(dct);
@@ -161,16 +161,16 @@ static inline void sync_templates(
     Py_DECREF(pyname);
 }
 
-static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, const unsigned int flags)
+static int BuildScopeProxyDict(cppjit::interop::TCppScope_t scope, PyObject* pyclass, const unsigned int flags)
 {
 // Collect methods and data for the given scope, and add them to the given python
 // proxy object.
 
 // some properties that'll affect building the dictionary
-    bool isNamespace = Cppyy::IsNamespace(scope);
-    bool isComplete = Cppyy::IsComplete(scope);
+    bool isNamespace = cppjit::interop::IsNamespace(scope);
+    bool isComplete = cppjit::interop::IsComplete(scope);
     bool hasConstructor = false;
-    Cppyy::TCppMethod_t potGetItem = nullptr;
+    cppjit::interop::TCppMethod_t potGetItem = nullptr;
 
 // load all public methods and data members
     typedef std::vector<PyCallable*> Callables_t;
@@ -183,24 +183,24 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
 
 // functions in namespaces are properly found through lazy lookup, so do not
 // create them until needed (the same is not true for data members)
-    std::vector<Cppyy::TCppMethod_t> methods;
-    if (isComplete) Cppyy::GetClassMethods(scope, methods);
+    std::vector<cppjit::interop::TCppMethod_t> methods;
+    if (isComplete) cppjit::interop::GetClassMethods(scope, methods);
 
     for (auto &method : methods) {
 
     // do not expose non-public methods as the Cling wrappers as those won't compile
-        if (!Cppyy::IsPublicMethod(method))
+        if (!cppjit::interop::IsPublicMethod(method))
             continue;
 
     // process the method based on its name
-        std::string mtCppName = Cppyy::GetName(Cppyy::TCppScope_t(method.data));
+        std::string mtCppName = cppjit::interop::GetName(cppjit::interop::TCppScope_t(method.data));
 
     // special case trackers
         bool setupSetItem = false;
-        bool isConstructor = Cppyy::IsConstructor(method);
+        bool isConstructor = cppjit::interop::IsConstructor(method);
 
     // Here isTemplate means to ignore templated constructors, that is handled in the next loop.
-        bool isTemplate = Cppyy::IsTemplatedMethod(method) && !isConstructor;
+        bool isTemplate = cppjit::interop::IsTemplatedMethod(method) && !isConstructor;
         bool isStubbedOperator = false;
 
     // filter empty names (happens for namespaces, is bug?)
@@ -213,20 +213,20 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
 
     // translate operators
         std::string mtName = Utility::MapOperatorName(
-            mtCppName, Cppyy::GetMethodNumArgs(method), &isStubbedOperator);
+            mtCppName, cppjit::interop::GetMethodNumArgs(method), &isStubbedOperator);
         if (mtName.empty())
             continue;
 
     // operator[]/() returning a reference type will be used for __setitem__
         bool isCall = mtName == "__call__";
         if (isCall || mtName == "__getitem__") {
-            const std::string& qual_return = Cppyy::GetMethodReturnTypeAsString(method);
+            const std::string& qual_return = cppjit::interop::GetMethodReturnTypeAsString(method);
             const std::string& cpd = TypeManip::compound(qual_return);
             if (!cpd.empty() && cpd[cpd.size()-1] == '&' && \
                     qual_return.find("const", 0, 5) == std::string::npos) {
                 if (isCall && !potGetItem) potGetItem = method;
                 setupSetItem = true;     // will add methods as overloads
-            } else if (isCall && 1 < Cppyy::GetMethodNumArgs(method)) {
+            } else if (isCall && 1 < cppjit::interop::GetMethodNumArgs(method)) {
             // not a non-const by-ref return, thus better __getitem__ candidate; the
             // requirement for multiple arguments is that there is otherwise no benefit
             // over the use of normal __getitem__ (this allows multi-indexing arguments,
@@ -245,14 +245,14 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
 
     // construct the holder
         PyCallable* pycall = nullptr;
-        if (Cppyy::IsStaticMethod(method))  // class method
+        if (cppjit::interop::IsStaticMethod(method))  // class method
             pycall = new CPPClassMethod(scope, method);
         else if (isNamespace)               // free function
             pycall = new CPPFunction(scope, method);
         else if (isConstructor) {           // ctor
             mtName = "__init__";
             hasConstructor = true;
-            if (!Cppyy::IsAbstract(scope)) {
+            if (!cppjit::interop::IsAbstract(scope)) {
                 if (flags & CPPScope::kIsMultiCross) {
                     pycall = new CPPMultiConstructor(scope, method);
                 } else
@@ -305,14 +305,14 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
 
 
 // add proxies for un-instantiated/non-overloaded templated methods
-    std::vector<Cppyy::TCppMethod_t> templ_methods;
-    Cppyy::GetTemplatedMethods(scope, templ_methods);
+    std::vector<cppjit::interop::TCppMethod_t> templ_methods;
+    cppjit::interop::GetTemplatedMethods(scope, templ_methods);
     for (auto &method : templ_methods) {
-        const std::string mtCppName = Cppyy::GetName(Cppyy::TCppScope_t(method.data));
+        const std::string mtCppName = cppjit::interop::GetName(cppjit::interop::TCppScope_t(method.data));
     // the number of arguments isn't known until instantiation and as far as C++ is concerned, all
     // same-named operators are simply overloads; so will pre-emptively add both names if with and
     // without arguments differ, letting the normal overload mechanism resolve on call
-        bool isConstructor = Cppyy::IsConstructor(method);
+        bool isConstructor = cppjit::interop::IsConstructor(method);
 
     // first add with no arguments
         std::string mtName0 = isConstructor ? "__init__" : Utility::MapOperatorName(mtCppName, false);
@@ -331,13 +331,13 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
         PyCallable* defctor = nullptr;
         if (!isComplete) {
             ((CPPScope*)pyclass)->fFlags |= CPPScope::kIsInComplete;
-            defctor = new CPPIncompleteClassConstructor(scope, Cppyy::TCppMethod_t{});
-        } else if (Cppyy::IsAbstract(scope)) {
-            defctor = new CPPAbstractClassConstructor(scope, Cppyy::TCppMethod_t{});
+            defctor = new CPPIncompleteClassConstructor(scope, cppjit::interop::TCppMethod_t{});
+        } else if (cppjit::interop::IsAbstract(scope)) {
+            defctor = new CPPAbstractClassConstructor(scope, cppjit::interop::TCppMethod_t{});
         } else if (isNamespace) {
-            defctor = new CPPNamespaceConstructor(scope, Cppyy::TCppMethod_t{});
+            defctor = new CPPNamespaceConstructor(scope, cppjit::interop::TCppMethod_t{});
         } else {
-            defctor = new CPPAllPrivateClassConstructor(scope, Cppyy::TCppMethod_t{});
+            defctor = new CPPAllPrivateClassConstructor(scope, cppjit::interop::TCppMethod_t{});
         }
 
         if (defctor)
@@ -357,7 +357,7 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
     // in order to prevent removing templated editions of this method (which were set earlier,
     // above, as a different proxy object), we'll check and add this method flagged as a generic
     // one (to be picked up by the templated one as appropriate) if a template exists
-        PyObject* pyname = CPyCppyy_PyText_FromString(const_cast<char*>(imd->first.c_str()));
+        PyObject* pyname = cpyrt_PyText_FromString(const_cast<char*>(imd->first.c_str()));
         PyObject* attr = PyObject_GetItem(dct, pyname);
         Py_DECREF(pyname);
         if (TemplateProxy_Check(attr)) {
@@ -368,7 +368,7 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
             if (!attr) PyErr_Clear();
         // normal case, add a new method
             CPPOverload* method = CPPOverload_New(imd->first, imd->second);
-            PyObject* pymname = CPyCppyy_PyText_InternFromString(const_cast<char*>(method->GetName().c_str()));
+            PyObject* pymname = cpyrt_PyText_InternFromString(const_cast<char*>(method->GetName().c_str()));
             PyType_Type.tp_setattro(pyclass, pymname, (PyObject*)method);
             Py_DECREF(pymname);
             Py_DECREF(method);
@@ -379,19 +379,19 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
     Py_DECREF(dct);
 
  // collect data members (including enums)
-    std::vector<Cppyy::TCppScope_t> datamembers;
-    Cppyy::GetDatamembers(scope, datamembers);
+    std::vector<cppjit::interop::TCppScope_t> datamembers;
+    cppjit::interop::GetDatamembers(scope, datamembers);
     for (auto &datamember : datamembers) {
     // allow only public members
-        if (!Cppyy::IsPublicData(datamember))
+        if (!cppjit::interop::IsPublicData(datamember))
             continue;
 
     // enum datamembers (this in conjunction with previously collected enums above)
-        if (Cppyy::IsEnumType(Cppyy::GetDatamemberType(datamember)) && Cppyy::IsEnumConstant(datamember)) {
+        if (cppjit::interop::IsEnumType(cppjit::interop::GetDatamemberType(datamember)) && cppjit::interop::IsEnumConstant(datamember)) {
         // two options: this is a static variable, or it is the enum value, the latter
         // already exists, so check for it and move on if set
             PyObject* eset = PyObject_GetAttrString(pyclass,
-                const_cast<char*>(Cppyy::GetFinalName(datamember).c_str()));
+                const_cast<char*>(cppjit::interop::GetFinalName(datamember).c_str()));
             if (eset) {
                 Py_DECREF(eset);
                 continue;
@@ -401,8 +401,8 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
 
         // it could still be that this is an anonymous enum, which is not in the list
         // provided by the class
-            if (strstr(Cppyy::GetDatamemberTypeAsString(datamember).c_str(), "(anonymous)") != 0 ||
-                strstr(Cppyy::GetDatamemberTypeAsString(datamember).c_str(), "(unnamed)")   != 0) {
+            if (strstr(cppjit::interop::GetDatamemberTypeAsString(datamember).c_str(), "(anonymous)") != 0 ||
+                strstr(cppjit::interop::GetDatamemberTypeAsString(datamember).c_str(), "(unnamed)")   != 0) {
                 AddPropertyToClass(pyclass, scope, datamember);
                 continue;
             }
@@ -420,15 +420,15 @@ static int BuildScopeProxyDict(Cppyy::TCppScope_t scope, PyObject* pyclass, cons
 }
 
 //----------------------------------------------------------------------------
-static void CollectUniqueBases(Cppyy::TCppScope_t klass, std::deque<Cppyy::TCppScope_t>& uqb)
+static void CollectUniqueBases(cppjit::interop::TCppScope_t klass, std::deque<cppjit::interop::TCppScope_t>& uqb)
 {
 // collect bases in acceptable mro order, while removing duplicates (this may
 // break the overload resolution in esoteric cases, but otherwise the class can
 // not be used at all, as CPython will refuse the mro).
-    size_t nbases = Cppyy::GetNumBases(klass);
+    size_t nbases = cppjit::interop::GetNumBases(klass);
 
     for (size_t ibase = 0; ibase < nbases; ++ibase) {
-        Cppyy::TCppScope_t tp = Cppyy::GetBaseScope(klass, ibase);
+        cppjit::interop::TCppScope_t tp = cppjit::interop::GetBaseScope(klass, ibase);
         int decision = 2;
         if (!tp) continue;   // means this base with not be available Python-side
         for (size_t ibase2 = 0; ibase2 < uqb.size(); ++ibase2) {
@@ -437,7 +437,7 @@ static void CollectUniqueBases(Cppyy::TCppScope_t klass, std::deque<Cppyy::TCppS
                 break;
             }
 
-            if (Cppyy::IsSubclass(tp, uqb[ibase2])) {
+            if (cppjit::interop::IsSubclass(tp, uqb[ibase2])) {
             // mro requirement: sub-type has to follow base
                 decision = 1;
                 break;
@@ -453,10 +453,10 @@ static void CollectUniqueBases(Cppyy::TCppScope_t klass, std::deque<Cppyy::TCppS
     }
 }
 
-static PyObject* BuildCppClassBases(Cppyy::TCppScope_t klass)
+static PyObject* BuildCppClassBases(cppjit::interop::TCppScope_t klass)
 {
 // Build a tuple of python proxy classes of all the bases of the given 'klass'.
-    std::deque<Cppyy::TCppScope_t> uqb;
+    std::deque<cppjit::interop::TCppScope_t> uqb;
     CollectUniqueBases(klass, uqb);
 
 // allocate a tuple for the base classes, special case for first base
@@ -471,7 +471,7 @@ static PyObject* BuildCppClassBases(Cppyy::TCppScope_t klass)
         Py_INCREF((PyObject*)(void*)&CPPInstance_Type);
         PyTuple_SET_ITEM(pybases, 0, (PyObject*)(void*)&CPPInstance_Type);
     } else {
-        for (std::deque<Cppyy::TCppScope_t>::size_type ibase = 0; ibase < nbases; ++ibase) {
+        for (std::deque<cppjit::interop::TCppScope_t>::size_type ibase = 0; ibase < nbases; ++ibase) {
             PyObject* pyclass = CreateScopeProxy(uqb[ibase]);
             if (!pyclass) {
                 Py_DECREF(pybases);
@@ -500,29 +500,29 @@ static PyObject* BuildCppClassBases(Cppyy::TCppScope_t klass)
     return pybases;
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::GetScopeProxy(Cppyy::TCppScope_t scope)
+PyObject* cppjit::cpyrt::GetScopeProxy(cppjit::interop::TCppScope_t scope)
 {
 // Retrieve scope proxy from the known ones.
     PyClassMap_t::iterator pci = gPyClasses.find(scope);
     if (pci != gPyClasses.end()) {
-        PyObject* pyclass = CPyCppyy_GetWeakRef(pci->second);
+        PyObject* pyclass = cpyrt_GetWeakRef(pci->second);
         if (pyclass)
             return pyclass;
     }
 
     return nullptr;
 }
-namespace CPyCppyy {
-PyObject *CppType_To_PyObject(Cppyy::TCppType_t type, std::string name, Cppyy::TCppScope_t parent_scope, PyObject *parent) {
-    Cppyy::TCppType_t resolved_type = Cppyy::ResolveType(type);
+namespace cppjit::cpyrt {
+PyObject *CppType_To_PyObject(cppjit::interop::TCppType_t type, std::string name, cppjit::interop::TCppScope_t parent_scope, PyObject *parent) {
+    cppjit::interop::TCppType_t resolved_type = cppjit::interop::ResolveType(type);
     if (gPyTypeMap) {
-        const std::string& resolved = Cppyy::GetTypeAsString(resolved_type);
+        const std::string& resolved = cppjit::interop::GetTypeAsString(resolved_type);
         PyObject* tc = PyDict_GetItemString(gPyTypeMap, resolved.c_str()); // borrowed
         if (tc && PyCallable_Check(tc)) {
-            const std::string& scName = Cppyy::GetScopedFinalName(parent_scope);
+            const std::string& scName = cppjit::interop::GetScopedFinalName(parent_scope);
             PyObject* nt = PyObject_CallFunction(tc, (char*)"ss", name.c_str(), scName != "<unnamed>" ? scName.c_str() : "");
             if (nt) {
                 if (parent) {
@@ -539,10 +539,10 @@ PyObject *CppType_To_PyObject(Cppyy::TCppType_t type, std::string name, Cppyy::T
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CreateScopeProxy(PyObject*, PyObject* args)
+PyObject* cppjit::cpyrt::CreateScopeProxy(PyObject*, PyObject* args)
 {
 // Build a python shadow class for the named C++ class.
-    std::string cname = CPyCppyy_PyText_AsString(PyTuple_GetItem(args, 0));
+    std::string cname = cpyrt_PyText_AsString(PyTuple_GetItem(args, 0));
     if (PyErr_Occurred())
         return nullptr;
 
@@ -550,12 +550,12 @@ PyObject* CPyCppyy::CreateScopeProxy(PyObject*, PyObject* args)
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CreateScopeProxy(const std::string& name, PyObject* parent, const unsigned flags)
+PyObject* cppjit::cpyrt::CreateScopeProxy(const std::string& name, PyObject* parent, const unsigned flags)
 {
 // Build a python shadow class for the named C++ class or namespace.
 
 // determine complete scope name, if a python parent has been given
-    Cppyy::TCppScope_t parent_scope;
+    cppjit::interop::TCppScope_t parent_scope;
     if (parent) {
         if (CPPScope_Check(parent))
             parent_scope = ((CPPScope*)parent)->fCppType;
@@ -567,11 +567,11 @@ PyObject* CPyCppyy::CreateScopeProxy(const std::string& name, PyObject* parent,
             }
 
         // should be a string
-            std::string scName = CPyCppyy_PyText_AsString(parname);
+            std::string scName = cpyrt_PyText_AsString(parname);
             Py_DECREF(parname);
             if (PyErr_Occurred())
                 return nullptr;
-            parent_scope = Cppyy::GetScope(scName);
+            parent_scope = cppjit::interop::GetScope(scName);
         }
 
         Py_INCREF(parent);
@@ -579,18 +579,18 @@ PyObject* CPyCppyy::CreateScopeProxy(const std::string& name, PyObject* parent,
 
 // retrieve C++ class (this verifies name, and is therefore done first)
     if (name == "") {
-        Cppyy::TCppScope_t klass = Cppyy::GetGlobalScope();
+        cppjit::interop::TCppScope_t klass = cppjit::interop::GetGlobalScope();
         Py_INCREF(gThisModule);
         parent = gThisModule;
         return CreateScopeProxy(klass, parent, flags);
-    } else if (Cppyy::TCppScope_t klass = Cppyy::GetScope(name, parent_scope)) {
-        if (Cppyy::IsTypedefed(klass) &&
-            Cppyy::IsPointerType(Cppyy::GetTypeFromScope(klass)) &&
-            Cppyy::IsClass(Cppyy::GetUnderlyingScope(klass)))
+    } else if (cppjit::interop::TCppScope_t klass = cppjit::interop::GetScope(name, parent_scope)) {
+        if (cppjit::interop::IsTypedefed(klass) &&
+            cppjit::interop::IsPointerType(cppjit::interop::GetTypeFromScope(klass)) &&
+            cppjit::interop::IsClass(cppjit::interop::GetUnderlyingScope(klass)))
             return nullptr; // this is handled by the caller; typedef to class pointer
         return CreateScopeProxy(klass, parent, flags);
-    } else if (Cppyy::IsBuiltin(name)) {
-        Cppyy::TCppType_t type = Cppyy::GetType(name);
+    } else if (cppjit::interop::IsBuiltin(name)) {
+        cppjit::interop::TCppType_t type = cppjit::interop::GetType(name);
         PyObject *result = nullptr;
         if (type)
             result = CppType_To_PyObject(type, name, parent_scope, parent);
@@ -604,18 +604,18 @@ PyObject* CPyCppyy::CreateScopeProxy(const std::string& name, PyObject* parent,
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CreateScopeProxy(Cppyy::TCppScope_t scope, PyObject* parent, const unsigned flags)
+PyObject* cppjit::cpyrt::CreateScopeProxy(cppjit::interop::TCppScope_t scope, PyObject* parent, const unsigned flags)
 {
 // Convenience function with a lookup first through the known existing proxies.
     PyObject* pyclass = GetScopeProxy(scope);
     if (pyclass)
         return pyclass;
 
-    Cppyy::TCppScope_t parent_scope = nullptr;
+    cppjit::interop::TCppScope_t parent_scope = nullptr;
     if (CPPScope_Check(parent))
         parent_scope = ((CPPScope*)parent)->fCppType;
     if (!parent_scope)
-        parent_scope = Cppyy::GetParentScope(scope);
+        parent_scope = cppjit::interop::GetParentScope(scope);
 
     if (!parent) {
         if (parent_scope)
@@ -626,32 +626,32 @@ PyObject* CPyCppyy::CreateScopeProxy(Cppyy::TCppScope_t scope, PyObject* parent,
         }
     }
 
-    std::string name = Cppyy::GetFinalName(scope);
+    std::string name = cppjit::interop::GetFinalName(scope);
     bool is_typedef = false;
     std::string typedefed_name = "";
-    if (Cppyy::IsTypedefed(scope)) {
+    if (cppjit::interop::IsTypedefed(scope)) {
         is_typedef = true;
-        typedefed_name = Cppyy::GetFullName(scope);
-        Cppyy::TCppScope_t underlying_scope = Cppyy::GetUnderlyingScope(scope);
+        typedefed_name = cppjit::interop::GetFullName(scope);
+        cppjit::interop::TCppScope_t underlying_scope = cppjit::interop::GetUnderlyingScope(scope);
         if ((underlying_scope) && (underlying_scope != scope)) {
             scope = underlying_scope;
         } else {
-            if (PyObject *result = CppType_To_PyObject(Cppyy::GetTypeFromScope(scope), name, parent_scope, parent))
+            if (PyObject *result = CppType_To_PyObject(cppjit::interop::GetTypeFromScope(scope), name, parent_scope, parent))
                 return result;
     
-            PyErr_Format(PyExc_TypeError, "\'%s\' is not a known C++ class", Cppyy::GetScopedFinalName(scope).c_str());
+            PyErr_Format(PyExc_TypeError, "\'%s\' is not a known C++ class", cppjit::interop::GetScopedFinalName(scope).c_str());
             Py_XDECREF(parent);
             return nullptr;
         }
     }
 
-    if (Cppyy::IsTemplate(scope)) {
+    if (cppjit::interop::IsTemplate(scope)) {
         // a "naked" templated class is requested: return callable proxy for instantiations
         PyObject* pytcl = PyObject_GetAttr(gThisModule, PyStrings::gTemplate);
         PyObject* cppscope = PyLong_FromVoidPtr(scope.data);
         PyObject* pytemplate = PyObject_CallFunction(
             pytcl, const_cast<char*>("sO"),
-            const_cast<char*>(Cppyy::GetScopedFinalName(scope).c_str()),
+            const_cast<char*>(cppjit::interop::GetScopedFinalName(scope).c_str()),
             cppscope);
         Py_DECREF(pytcl);
 
@@ -663,7 +663,7 @@ PyObject* CPyCppyy::CreateScopeProxy(Cppyy::TCppScope_t scope, PyObject* parent,
         return pytemplate;
     }
 
-    if (Cppyy::IsEnumScope(scope))
+    if (cppjit::interop::IsEnumScope(scope))
         return nullptr;
 
 // locate class by ID, if possible, to prevent parsing scopes/templates anew
@@ -696,7 +696,7 @@ PyObject* CPyCppyy::CreateScopeProxy(Cppyy::TCppScope_t scope, PyObject* parent,
             }
         }
 
-    // store a ref from cppyy scope id to new python class
+    // store a ref from cppjit scope id to new python class
         if (pyscope && !(((CPPScope*)pyscope)->fFlags & CPPScope::kIsInComplete)) {
             gPyClasses[scope] = PyWeakref_NewRef(pyscope, nullptr);
 
@@ -709,8 +709,8 @@ PyObject* CPyCppyy::CreateScopeProxy(Cppyy::TCppScope_t scope, PyObject* parent,
             } else {
             // add to sys.modules to allow importing from this namespace
                 PyObject* pyfullname = PyObject_GetAttr(pyscope, PyStrings::gModule);
-                CPyCppyy_PyText_AppendAndDel(&pyfullname, CPyCppyy_PyText_FromString("."));
-                CPyCppyy_PyText_AppendAndDel(&pyfullname, PyObject_GetAttr(pyscope, PyStrings::gName));
+                cpyrt_PyText_AppendAndDel(&pyfullname, cpyrt_PyText_FromString("."));
+                cpyrt_PyText_AppendAndDel(&pyfullname, PyObject_GetAttr(pyscope, PyStrings::gName));
                 PyObject* modules = PySys_GetObject(const_cast<char*>("modules"));
                 if (modules && PyDict_Check(modules))
                     PyDict_SetItem(modules, pyfullname, pyscope);
@@ -722,8 +722,8 @@ PyObject* CPyCppyy::CreateScopeProxy(Cppyy::TCppScope_t scope, PyObject* parent,
 // store on parent if found/created and complete
     if (pyscope && !(((CPPScope*)pyscope)->fFlags & CPPScope::kIsInComplete)) {
         // FIXME: This is to mimic original behaviour. Still required?
-        if (Cppyy::IsTemplateInstantiation(scope))
-            name = Cppyy::GetScopedFinalName(scope);
+        if (cppjit::interop::IsTemplateInstantiation(scope))
+            name = cppjit::interop::GetScopedFinalName(scope);
         if (is_typedef && !typedefed_name.empty())
             AddScopeToParent(parent, typedefed_name, pyscope);
         AddScopeToParent(parent, name, pyscope);
@@ -736,7 +736,7 @@ PyObject* CPyCppyy::CreateScopeProxy(Cppyy::TCppScope_t scope, PyObject* parent,
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyObject* parent)
+PyObject* cppjit::cpyrt::CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyObject* parent)
 {
 // To allow use of C++ exceptions in lieue of Python exceptions, they need to
 // derive from BaseException, which can not mix with the normal CPPInstance and
@@ -744,7 +744,7 @@ PyObject* CPyCppyy::CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyO
 // derives from Pythons Exception class
 
 // start with creation of CPPExcInstance type base classes
-    std::deque<Cppyy::TCppScope_t> uqb;
+    std::deque<cppjit::interop::TCppScope_t> uqb;
     CollectUniqueBases(((CPPScope*)pyscope)->fCppType, uqb);
     size_t nbases = uqb.size();
 
@@ -766,10 +766,10 @@ PyObject* CPyCppyy::CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyO
     } else {
         PyObject* best_base = nullptr;
 
-        for (std::deque<Cppyy::TCppScope_t>::size_type ibase = 0; ibase < nbases; ++ibase) {
+        for (std::deque<cppjit::interop::TCppScope_t>::size_type ibase = 0; ibase < nbases; ++ibase) {
         // retrieve bases through their enclosing scope to guarantee treatment as
         // exception classes and proper caching
-            Cppyy::TCppScope_t parent_scope = Cppyy::GetParentScope(uqb[ibase]);
+            cppjit::interop::TCppScope_t parent_scope = cppjit::interop::GetParentScope(uqb[ibase]);
             PyObject* base_parent = CreateScopeProxy(parent_scope);
             if (!base_parent) {
                 Py_DECREF(pybases);
@@ -777,7 +777,7 @@ PyObject* CPyCppyy::CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyO
             }
 
             PyObject* excbase = PyObject_GetAttrString(base_parent,
-                Cppyy::GetFinalName(uqb[ibase]).c_str());
+                cppjit::interop::GetFinalName(uqb[ibase]).c_str());
             Py_DECREF(base_parent);
             if (!excbase) {
                 Py_DECREF(pybases);
@@ -788,7 +788,7 @@ PyObject* CPyCppyy::CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyO
                 Py_XDECREF(best_base);
                 best_base = excbase;
 
-                if (Cppyy::GetScopedFinalName(uqb[ibase]) != "std::exception")
+                if (cppjit::interop::GetScopedFinalName(uqb[ibase]) != "std::exception")
                     break;
             } else {
             // just skip: there will be at least one exception derived base class
@@ -821,8 +821,8 @@ PyObject* CPyCppyy::CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyO
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::BindCppObjectNoCast(Cppyy::TCppObject_t address,
-        Cppyy::TCppScope_t klass, const unsigned flags)
+PyObject* cppjit::cpyrt::BindCppObjectNoCast(cppjit::interop::TCppObject_t address,
+        cppjit::interop::TCppScope_t klass, const unsigned flags)
 {
 // only known or knowable objects will be bound (null object is ok)
     if (!klass) {
@@ -843,7 +843,7 @@ PyObject* CPyCppyy::BindCppObjectNoCast(Cppyy::TCppObject_t address,
     PyObject* smart_type = (!(flags & CPPInstance::kNoWrapConv) && \
                             (((CPPClass*)pyclass)->fFlags & CPPScope::kIsSmart)) ? pyclass : nullptr;
     if (smart_type) {
-        Cppyy::TCppScope_t underlying = ((CPPSmartClass*)smart_type)->fUnderlyingType;
+        cppjit::interop::TCppScope_t underlying = ((CPPSmartClass*)smart_type)->fUnderlyingType;
 
     // Downcast the underlying object to its actual (most derived) class, as
     // BindCppObject does for raw pointers, but only when the cast is safe:
@@ -855,12 +855,12 @@ PyObject* CPyCppyy::BindCppObjectNoCast(Cppyy::TCppObject_t address,
     //    not be applied consistently on later member access (multiple
     //    inheritance).
         if (address && !isRef) {
-            if (void* deref = Cppyy::CallR(
+            if (void* deref = cppjit::interop::CallR(
                 ((CPPSmartClass*)smart_type)->fDereferencer, address, 0, nullptr)) {
-                Cppyy::TCppScope_t clActual = Cppyy::GetActualClass(underlying, deref);
+                cppjit::interop::TCppScope_t clActual = cppjit::interop::GetActualClass(underlying, deref);
                 if (clActual && clActual != underlying &&
-                        Cppyy::IsSubclass(clActual, underlying) &&
-                        Cppyy::GetBaseOffset(clActual, underlying, deref, -1 /* down-cast */) == 0)
+                        cppjit::interop::IsSubclass(clActual, underlying) &&
+                        cppjit::interop::GetBaseOffset(clActual, underlying, deref, -1 /* down-cast */) == 0)
                     underlying = clActual;
             }
         }
@@ -930,8 +930,8 @@ PyObject* CPyCppyy::BindCppObjectNoCast(Cppyy::TCppObject_t address,
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::BindCppObject(Cppyy::TCppObject_t address,
-        Cppyy::TCppScope_t klass, const unsigned flags)
+PyObject* cppjit::cpyrt::BindCppObject(cppjit::interop::TCppObject_t address,
+        cppjit::interop::TCppScope_t klass, const unsigned flags)
 {
 // if the object is a null pointer, return a typed one (as needed for overloading)
     if (!address)
@@ -951,11 +951,11 @@ PyObject* CPyCppyy::BindCppObject(Cppyy::TCppObject_t address,
 // TODO: optimize for final classes
     unsigned new_flags = flags;
     if (!isRef && (gPinnedTypes.empty() || gPinnedTypes.find(klass) == gPinnedTypes.end())) {
-        Cppyy::TCppScope_t clActual = Cppyy::GetActualClass(klass, address);
+        cppjit::interop::TCppScope_t clActual = cppjit::interop::GetActualClass(klass, address);
 
         if (clActual) {
             if (clActual != klass) {
-                intptr_t offset = Cppyy::GetBaseOffset(
+                intptr_t offset = cppjit::interop::GetBaseOffset(
                     clActual, klass, address, -1 /* down-cast */, true /* report errors */);
                 if (offset != -1) {   // may fail if clActual not fully defined
                     address = (void*)((intptr_t)address.data + offset);
@@ -971,8 +971,8 @@ PyObject* CPyCppyy::BindCppObject(Cppyy::TCppObject_t address,
 }
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::BindCppObjectArray(
-    Cppyy::TCppObject_t address, Cppyy::TCppScope_t klass, cdims_t dims)
+PyObject* cppjit::cpyrt::BindCppObjectArray(
+    cppjit::interop::TCppObject_t address, cppjit::interop::TCppScope_t klass, cdims_t dims)
 {
 // TODO: this function exists for symmetry; need to figure out if it's useful
     return TupleOfInstances_New(address, klass, dims);
diff --git a/src/cpyrt/ProxyWrappers.h b/src/cpyrt/ProxyWrappers.h
new file mode 100644
index 0000000..e5be7a7
--- /dev/null
+++ b/src/cpyrt/ProxyWrappers.h
@@ -0,0 +1,33 @@
+#ifndef CPYRT_PROXYWRAPPERS_H
+#define CPYRT_PROXYWRAPPERS_H
+
+// Bindings
+#include "Dimensions.h"
+
+// Standard
+#include <string>
+
+
+namespace cppjit::cpyrt {
+
+// construct a Python shadow class for the named C++ class
+PyObject* GetScopeProxy(cppjit::interop::TCppScope_t);
+PyObject* CreateScopeProxy(PyObject*, PyObject* args);
+PyObject* CreateScopeProxy(
+    const std::string& scope_name, PyObject* parent = nullptr, const unsigned flags = 0);
+
+PyObject* CreateScopeProxy(cppjit::interop::TCppScope_t scope, PyObject* parent = nullptr, const unsigned flags = 0);
+// C++ exceptions form a special case b/c they have to derive from BaseException
+PyObject* CreateExcScopeProxy(PyObject* pyscope, PyObject* pyname, PyObject* parent);
+
+// bind a C++ object into a Python proxy object (flags are CPPInstance::Default)
+PyObject* BindCppObjectNoCast(cppjit::interop::TCppObject_t object,
+    cppjit::interop::TCppScope_t klass, const unsigned flags = 0);
+PyObject* BindCppObject(cppjit::interop::TCppObject_t object,
+    cppjit::interop::TCppScope_t klass, const unsigned flags = 0);
+PyObject* BindCppObjectArray(
+    cppjit::interop::TCppObject_t address, cppjit::interop::TCppScope_t klass, cdims_t dims);
+
+} // namespace cppjit::cpyrt
+
+#endif // !CPYRT_PROXYWRAPPERS_H
diff --git a/src/CPyCppyy/src/PyCallable.h b/src/cpyrt/PyCallable.h
similarity index 68%
rename from src/CPyCppyy/src/PyCallable.h
rename to src/cpyrt/PyCallable.h
index d2a072c..38a2af0 100644
--- a/src/CPyCppyy/src/PyCallable.h
+++ b/src/cpyrt/PyCallable.h
@@ -1,14 +1,14 @@
-#ifndef CPYCPPYY_PYCALLABLE_H
-#define CPYCPPYY_PYCALLABLE_H
+#ifndef CPYRT_PYCALLABLE_H
+#define CPYRT_PYCALLABLE_H
 
 #include <climits>
 
 // Bindings
-#include "CPyCppyy/Reflex.h"
+#include "cpyrt/Reflex.h"
 #include "CallContext.h"
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class CPPInstance;
 
@@ -23,8 +23,8 @@ class PyCallable {
     virtual PyObject* GetPrototype(bool show_formalargs = true) = 0;
     virtual PyObject* GetTypeName() { return GetPrototype(false); }
     virtual PyObject* GetDocString() { return GetPrototype(); }
-    virtual PyObject* Reflex(Cppyy::Reflex::RequestId_t request,
-                             Cppyy::Reflex::FormatId_t format = Cppyy::Reflex::OPTIMAL) {
+    virtual PyObject* Reflex(cppjit::interop::Reflex::RequestId_t request,
+                             cppjit::interop::Reflex::FormatId_t format = cppjit::interop::Reflex::OPTIMAL) {
         PyErr_Format(PyExc_ValueError, "unsupported reflex request %d or format %d", request, format);
         return nullptr;
     };
@@ -38,7 +38,7 @@ class PyCallable {
     virtual bool IsConst() { return false; }
 
     virtual PyObject* GetScopeProxy() = 0;
-    virtual Cppyy::TCppFuncAddr_t GetFunctionAddress() = 0;
+    virtual cppjit::interop::TCppFuncAddr_t GetFunctionAddress() = 0;
 
     virtual PyCallable* Clone() = 0;
 
@@ -46,9 +46,9 @@ class PyCallable {
 
 public:
     virtual PyObject* Call(CPPInstance*& self,
-        CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) = 0;
+        cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, CallContext* ctxt = nullptr) = 0;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_PYCALLABLE_H
+#endif // !CPYRT_PYCALLABLE_H
diff --git a/src/CPyCppyy/src/PyException.cxx b/src/cpyrt/PyException.cxx
similarity index 87%
rename from src/CPyCppyy/src/PyException.cxx
rename to src/cpyrt/PyException.cxx
index df4b664..02f6c52 100644
--- a/src/CPyCppyy/src/PyException.cxx
+++ b/src/cpyrt/PyException.cxx
@@ -2,11 +2,11 @@
 #include <string.h>
 
 // Bindings
-#include "CPyCppyy.h"
-#define CPYCPPYY_INTERNAL 1
-#include "CPyCppyy/DispatchPtr.h"
-#include "CPyCppyy/PyException.h"
-#undef CPYCPPYY_INTERNAL
+#include "cpyrt.h"
+#define CPYRT_INTERNAL 1
+#include "cpyrt/DispatchPtr.h"
+#include "cpyrt/PyException.h"
+#undef CPYRT_INTERNAL
 
 
 //______________________________________________________________________________
@@ -23,7 +23,7 @@
 
 
 //- constructors/destructor --------------------------------------------------
-CPyCppyy::PyException::PyException()
+cppjit::cpyrt::PyException::PyException()
 {
 #ifdef WITH_THREAD
     PythonGILRAII python_gil_raii;
@@ -51,7 +51,7 @@ CPyCppyy::PyException::PyException()
 
         PyObject* msg = PyObject_Str(pyvalue);
         if (msg) {
-           fMsg += CPyCppyy_PyText_AsString(msg);
+           fMsg += cpyrt_PyText_AsString(msg);
            Py_DECREF(msg);
         }
     }
@@ -69,13 +69,13 @@ CPyCppyy::PyException::PyException()
         Py_DECREF(code);
 
         PyObject* filenameStr = PyObject_Str(filename);
-        locFile = CPyCppyy_PyText_AsString(filenameStr);
+        locFile = cpyrt_PyText_AsString(filenameStr);
         Py_DECREF(filenameStr);
         Py_DECREF(filename);
 
         PyObject* name = PyObject_GetAttrString(code, "co_name");
         PyObject* nameStr = PyObject_Str(name);
-        locName = CPyCppyy_PyText_AsString(nameStr);
+        locName = cpyrt_PyText_AsString(nameStr);
         Py_DECREF(nameStr);
         Py_DECREF(name);
 
@@ -118,20 +118,20 @@ CPyCppyy::PyException::PyException()
     }
 }
 
-CPyCppyy::PyException::~PyException() noexcept
+cppjit::cpyrt::PyException::~PyException() noexcept
 {
 // destructor
 }
 
 
 //- public members -----------------------------------------------------------
-const char* CPyCppyy::PyException::what() const noexcept
+const char* cppjit::cpyrt::PyException::what() const noexcept
 {
 // Return reason for throwing this exception: a python exception was raised.
     return fMsg.c_str();
 }
 
-void CPyCppyy::PyException::clear() const noexcept
+void cppjit::cpyrt::PyException::clear() const noexcept
 {
 #ifdef WITH_THREAD
     PythonGILRAII python_gil_raii;
diff --git a/src/CPyCppyy/include/CPyCppyy/PyException.h b/src/cpyrt/PyException.h
similarity index 87%
rename from src/CPyCppyy/include/CPyCppyy/PyException.h
rename to src/cpyrt/PyException.h
index 5c8133d..306e11f 100644
--- a/src/CPyCppyy/include/CPyCppyy/PyException.h
+++ b/src/cpyrt/PyException.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_PYEXCEPTION_H
-#define CPYCPPYY_PYEXCEPTION_H
+#ifndef CPYRT_PYEXCEPTION_H
+#define CPYRT_PYEXCEPTION_H
 
 //////////////////////////////////////////////////////////////////////////////
 //                                                                          //
@@ -14,7 +14,7 @@
 //   - The C++ code can call back to python.                                //
 //   - What to do then if the python callback throws an exception?          //
 //                                                                          //
-// We need to get the control flow back to where CPyCppyy calls C++.        //
+// We need to get the control flow back to where cpyrt calls C++.        //
 // To do that we throw a TPyException.                                      //
 // We can then catch this exception when we do the C++ call.                //
 //                                                                          //
@@ -31,12 +31,12 @@
 #include <string>
 
 // Bindings
-#include "CPyCppyy/CommonDefs.h"
+#include "cpyrt/CommonDefs.h"
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
-class CPYCPPYY_CLASS_EXTERN PyException : public std::exception {
+class CPYRT_CLASS_EXTERN PyException : public std::exception {
 public:
     PyException();
     ~PyException() noexcept override;
@@ -51,6 +51,6 @@ class CPYCPPYY_CLASS_EXTERN PyException : public std::exception {
     std::string fMsg;
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_PYEXCEPTION_H
+#endif // !CPYRT_PYEXCEPTION_H
diff --git a/src/CPyCppyy/src/PyObjectDir27.inc b/src/cpyrt/PyObjectDir27.inc
similarity index 100%
rename from src/CPyCppyy/src/PyObjectDir27.inc
rename to src/cpyrt/PyObjectDir27.inc
diff --git a/src/cpyrt/PyStrings.cxx b/src/cpyrt/PyStrings.cxx
new file mode 100644
index 0000000..7545104
--- /dev/null
+++ b/src/cpyrt/PyStrings.cxx
@@ -0,0 +1,241 @@
+// Bindings
+#include "cpyrt.h"
+#include "PyStrings.h"
+
+
+//- data _____________________________________________________________________
+PyObject* cppjit::cpyrt::PyStrings::gAssign           = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gBases            = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gBase             = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gContains         = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCopy             = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCppBool          = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCppName          = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gAnnotations      = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCastCpp          = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCType            = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gDeref            = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gPreInc           = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gPostInc          = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gDict             = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gEmptyString      = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gEq               = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gFollow           = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gGetItem          = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gGetNoCheck       = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gSetItem          = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gInit             = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gIter             = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gLen              = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gLifeLine         = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gModule           = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gMRO              = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gName             = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gNe               = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gRepr             = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCppRepr          = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gStr              = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCppStr           = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gTypeCode         = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCTypesType       = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gUnderlying       = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gRealInit         = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gAdd              = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gSub              = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gMul              = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gDiv              = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gLShift           = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gLShiftC          = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gAt               = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gBegin            = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gEnd              = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gFirst            = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gSecond           = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gSize             = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gTemplate         = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gVectorAt         = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gInsert           = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gValueType        = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gValueTypePtr     = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gValueSize        = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gCppReal          = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gCppImag          = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gThisModule       = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gDispInit         = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gDispGet          = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gExPythonize      = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gPythonize        = nullptr;
+
+PyObject* cppjit::cpyrt::PyStrings::gArray            = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gDType            = nullptr;
+PyObject* cppjit::cpyrt::PyStrings::gFromBuffer       = nullptr;
+
+
+//-----------------------------------------------------------------------------
+#define CPPJIT_INITIALIZE_STRING(var, str)                                     \
+    if (!(PyStrings::var = cpyrt_PyText_InternFromString((char*)#str)))    \
+        return false
+
+bool cppjit::cpyrt::CreatePyStrings() {
+// Build cache of commonly used python strings (the cache is python intern, so
+// all strings are shared python-wide, not just in cppjit).
+    CPPJIT_INITIALIZE_STRING(gAssign,         __assign__);
+    CPPJIT_INITIALIZE_STRING(gBases,          __bases__);
+    CPPJIT_INITIALIZE_STRING(gBase,           __base__);
+    CPPJIT_INITIALIZE_STRING(gContains,       contains);
+    CPPJIT_INITIALIZE_STRING(gCopy,           copy);
+    CPPJIT_INITIALIZE_STRING(gCppBool,        __cpp_bool__);
+    CPPJIT_INITIALIZE_STRING(gCppName,        __cpp_name__);
+    CPPJIT_INITIALIZE_STRING(gAnnotations,    __annotations__);
+    CPPJIT_INITIALIZE_STRING(gCastCpp,        __cast_cpp__);
+    CPPJIT_INITIALIZE_STRING(gCType,          __ctype__);
+    CPPJIT_INITIALIZE_STRING(gDeref,          __deref__);
+    CPPJIT_INITIALIZE_STRING(gPreInc,         __preinc__);
+    CPPJIT_INITIALIZE_STRING(gPostInc,        __postinc__);
+    CPPJIT_INITIALIZE_STRING(gDict,           __dict__);
+    if (!(PyStrings::gEmptyString = cpyrt_PyText_FromString((char*)"")))
+        return false;
+    CPPJIT_INITIALIZE_STRING(gEq,             __eq__);
+    CPPJIT_INITIALIZE_STRING(gFollow,         __follow__);
+    CPPJIT_INITIALIZE_STRING(gGetItem,        __getitem__);
+    CPPJIT_INITIALIZE_STRING(gGetNoCheck,     _getitem__unchecked);
+    CPPJIT_INITIALIZE_STRING(gSetItem,        __setitem__);
+    CPPJIT_INITIALIZE_STRING(gInit,           __init__);
+    CPPJIT_INITIALIZE_STRING(gIter,           __iter__);
+    CPPJIT_INITIALIZE_STRING(gLen,            __len__);
+    CPPJIT_INITIALIZE_STRING(gLifeLine,       __lifeline);
+    CPPJIT_INITIALIZE_STRING(gModule,         __module__);
+    CPPJIT_INITIALIZE_STRING(gMRO,            __mro__);
+    CPPJIT_INITIALIZE_STRING(gName,           __name__);
+    CPPJIT_INITIALIZE_STRING(gNe,             __ne__);
+    CPPJIT_INITIALIZE_STRING(gRepr,           __repr__);
+    CPPJIT_INITIALIZE_STRING(gCppRepr,        __cpp_repr);
+    CPPJIT_INITIALIZE_STRING(gStr,            __str__);
+    CPPJIT_INITIALIZE_STRING(gCppStr,         __cpp_str);
+    CPPJIT_INITIALIZE_STRING(gTypeCode,       typecode);
+    CPPJIT_INITIALIZE_STRING(gCTypesType,     _type_);
+
+    CPPJIT_INITIALIZE_STRING(gUnderlying,     __underlying);
+    CPPJIT_INITIALIZE_STRING(gRealInit,       __real_init);
+
+    CPPJIT_INITIALIZE_STRING(gAdd,            __add__);
+    CPPJIT_INITIALIZE_STRING(gSub,            __sub__);
+    CPPJIT_INITIALIZE_STRING(gMul,            __mul__);
+    CPPJIT_INITIALIZE_STRING(gDiv,            CPPJIT__div__);
+
+    CPPJIT_INITIALIZE_STRING(gLShift,         __lshift__);
+    CPPJIT_INITIALIZE_STRING(gLShiftC,        __lshiftc__);
+
+    CPPJIT_INITIALIZE_STRING(gAt,             at);
+    CPPJIT_INITIALIZE_STRING(gBegin,          begin);
+    CPPJIT_INITIALIZE_STRING(gEnd,            end);
+    CPPJIT_INITIALIZE_STRING(gFirst,          first);
+    CPPJIT_INITIALIZE_STRING(gSecond,         second);
+    CPPJIT_INITIALIZE_STRING(gSize,           size);
+    CPPJIT_INITIALIZE_STRING(gTemplate,       Template);
+    CPPJIT_INITIALIZE_STRING(gVectorAt,       _vector__at);
+    CPPJIT_INITIALIZE_STRING(gInsert,         insert);
+    CPPJIT_INITIALIZE_STRING(gValueType,      value_type);
+    CPPJIT_INITIALIZE_STRING(gValueTypePtr,   _value_type);
+    CPPJIT_INITIALIZE_STRING(gValueSize,      value_size);
+
+    CPPJIT_INITIALIZE_STRING(gCppReal,        __cpp_real);
+    CPPJIT_INITIALIZE_STRING(gCppImag,        __cpp_imag);
+
+    CPPJIT_INITIALIZE_STRING(gThisModule,     cppjit);
+
+    CPPJIT_INITIALIZE_STRING(gDispInit,       _init_dispatchptr);
+    CPPJIT_INITIALIZE_STRING(gDispGet,        _get_dispatch);
+
+    CPPJIT_INITIALIZE_STRING(gExPythonize,    __cppjit_explicit_pythonize__);
+    CPPJIT_INITIALIZE_STRING(gPythonize,      __cppjit_pythonize__);
+
+    CPPJIT_INITIALIZE_STRING(gArray,          __array__);
+    CPPJIT_INITIALIZE_STRING(gDType,          dtype);
+    CPPJIT_INITIALIZE_STRING(gFromBuffer,     frombuffer);
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+PyObject* cppjit::cpyrt::DestroyPyStrings() {
+// Remove all cached python strings.
+    Py_DECREF(PyStrings::gBases);       PyStrings::gBases       = nullptr;
+    Py_DECREF(PyStrings::gBase);        PyStrings::gBase        = nullptr;
+    Py_DECREF(PyStrings::gContains);    PyStrings::gContains    = nullptr;
+    Py_DECREF(PyStrings::gCopy);        PyStrings::gCopy        = nullptr;
+    Py_DECREF(PyStrings::gCppBool);     PyStrings::gCppBool     = nullptr;
+    Py_DECREF(PyStrings::gCppName);     PyStrings::gCppName     = nullptr;
+    Py_DECREF(PyStrings::gAnnotations); PyStrings::gAnnotations = nullptr;
+    Py_DECREF(PyStrings::gCType);       PyStrings::gCType       = nullptr;
+    Py_DECREF(PyStrings::gDeref);       PyStrings::gDeref       = nullptr;
+    Py_DECREF(PyStrings::gPreInc);      PyStrings::gPreInc      = nullptr;
+    Py_DECREF(PyStrings::gPostInc);     PyStrings::gPostInc     = nullptr;
+    Py_DECREF(PyStrings::gDict);        PyStrings::gDict        = nullptr;
+    Py_DECREF(PyStrings::gEmptyString); PyStrings::gEmptyString = nullptr;
+    Py_DECREF(PyStrings::gEq);          PyStrings::gEq          = nullptr;
+    Py_DECREF(PyStrings::gFollow);      PyStrings::gFollow      = nullptr;
+    Py_DECREF(PyStrings::gGetItem);     PyStrings::gGetItem     = nullptr;
+    Py_DECREF(PyStrings::gGetNoCheck);  PyStrings::gGetNoCheck  = nullptr;
+    Py_DECREF(PyStrings::gSetItem);     PyStrings::gSetItem     = nullptr;
+    Py_DECREF(PyStrings::gInit);        PyStrings::gInit        = nullptr;
+    Py_DECREF(PyStrings::gIter);        PyStrings::gIter        = nullptr;
+    Py_DECREF(PyStrings::gLen);         PyStrings::gLen         = nullptr;
+    Py_DECREF(PyStrings::gLifeLine);    PyStrings::gLifeLine    = nullptr;
+    Py_DECREF(PyStrings::gModule);      PyStrings::gModule      = nullptr;
+    Py_DECREF(PyStrings::gMRO);         PyStrings::gMRO         = nullptr;
+    Py_DECREF(PyStrings::gName);        PyStrings::gName        = nullptr;
+    Py_DECREF(PyStrings::gNe);          PyStrings::gNe          = nullptr;
+    Py_DECREF(PyStrings::gTypeCode);    PyStrings::gTypeCode    = nullptr;
+    Py_DECREF(PyStrings::gCTypesType);  PyStrings::gCTypesType  = nullptr;
+
+    Py_DECREF(PyStrings::gUnderlying);  PyStrings::gUnderlying  = nullptr;
+    Py_DECREF(PyStrings::gRealInit);    PyStrings::gRealInit    = nullptr;
+
+    Py_DECREF(PyStrings::gAdd);         PyStrings::gAdd         = nullptr;
+    Py_DECREF(PyStrings::gSub);         PyStrings::gSub         = nullptr;
+    Py_DECREF(PyStrings::gMul);         PyStrings::gMul         = nullptr;
+    Py_DECREF(PyStrings::gDiv);         PyStrings::gDiv         = nullptr;
+
+    Py_DECREF(PyStrings::gLShift);      PyStrings::gLShift      = nullptr;
+    Py_DECREF(PyStrings::gLShiftC);     PyStrings::gLShiftC     = nullptr;
+
+    Py_DECREF(PyStrings::gAt);          PyStrings::gAt          = nullptr;
+    Py_DECREF(PyStrings::gBegin);       PyStrings::gBegin       = nullptr;
+    Py_DECREF(PyStrings::gEnd);         PyStrings::gEnd         = nullptr;
+    Py_DECREF(PyStrings::gFirst);       PyStrings::gFirst       = nullptr;
+    Py_DECREF(PyStrings::gSecond);      PyStrings::gSecond      = nullptr;
+    Py_DECREF(PyStrings::gSize);        PyStrings::gSize        = nullptr;
+    Py_DECREF(PyStrings::gTemplate);    PyStrings::gTemplate    = nullptr;
+    Py_DECREF(PyStrings::gVectorAt);    PyStrings::gVectorAt    = nullptr;
+    Py_DECREF(PyStrings::gInsert);      PyStrings::gInsert      = nullptr;
+    Py_DECREF(PyStrings::gValueType);   PyStrings::gValueType   = nullptr;
+    Py_DECREF(PyStrings::gValueTypePtr);PyStrings::gValueTypePtr= nullptr;
+    Py_DECREF(PyStrings::gValueSize);   PyStrings::gValueSize   = nullptr;
+
+    Py_DECREF(PyStrings::gCppReal);     PyStrings::gCppReal     = nullptr;
+    Py_DECREF(PyStrings::gCppImag);     PyStrings::gCppImag     = nullptr;
+
+    Py_DECREF(PyStrings::gThisModule);  PyStrings::gThisModule  = nullptr;
+
+    Py_DECREF(PyStrings::gDispInit);    PyStrings::gDispInit    = nullptr;
+    Py_DECREF(PyStrings::gDispGet);     PyStrings::gDispGet     = nullptr;
+
+    Py_DECREF(PyStrings::gExPythonize); PyStrings::gExPythonize = nullptr;
+    Py_DECREF(PyStrings::gPythonize);   PyStrings::gPythonize   = nullptr;
+
+    Py_DECREF(PyStrings::gArray);       PyStrings::gArray       = nullptr;
+    Py_DECREF(PyStrings::gDType);       PyStrings::gDType       = nullptr;
+    Py_DECREF(PyStrings::gFromBuffer);  PyStrings::gFromBuffer  = nullptr;
+
+    Py_RETURN_NONE;
+}
diff --git a/src/CPyCppyy/src/PyStrings.h b/src/cpyrt/PyStrings.h
similarity index 93%
rename from src/CPyCppyy/src/PyStrings.h
rename to src/cpyrt/PyStrings.h
index ed6a677..46593ab 100644
--- a/src/CPyCppyy/src/PyStrings.h
+++ b/src/cpyrt/PyStrings.h
@@ -1,7 +1,7 @@
-#ifndef CPYCPPYY_PYSTRINGS_H
-#define CPYCPPYY_PYSTRINGS_H
+#ifndef CPYRT_PYSTRINGS_H
+#define CPYRT_PYSTRINGS_H
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 // python strings kept for performance reasons
 
@@ -86,6 +86,6 @@ namespace PyStrings {
 bool CreatePyStrings();
 PyObject* DestroyPyStrings();
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_PYSTRINGS_H
+#endif // !CPYRT_PYSTRINGS_H
diff --git a/src/CPyCppyy/src/Pythonize.cxx b/src/cpyrt/Pythonize.cxx
similarity index 91%
rename from src/CPyCppyy/src/Pythonize.cxx
rename to src/cpyrt/Pythonize.cxx
index 7580fbd..6030810 100644
--- a/src/CPyCppyy/src/Pythonize.cxx
+++ b/src/cpyrt/Pythonize.cxx
@@ -1,11 +1,11 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "Pythonize.h"
 #include "Converters.h"
 #include "CPPInstance.h"
 #include "CPPFunction.h"
 #include "CPPOverload.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "CustomPyTypes.h"
 #include "LowLevelViews.h"
 #include "ProxyWrappers.h"
@@ -25,7 +25,7 @@
 
 
 //- data and local helpers ---------------------------------------------------
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     extern PyObject* gThisModule;
     std::unordered_map<std::string, std::vector<PyObject*>> &pythonizations();
 }
@@ -33,10 +33,10 @@ namespace CPyCppyy {
 namespace {
 
 // for convenience
-using namespace CPyCppyy;
+using namespace cppjit::cpyrt;
 
 //-----------------------------------------------------------------------------
-bool HasAttrDirect(PyObject* pyclass, PyObject* pyname, bool mustBeCPyCppyy = false) {
+bool HasAttrDirect(PyObject* pyclass, PyObject* pyname, bool mustBecpyrt = false) {
 // prevents calls to Py_TYPE(pyclass)->tp_getattr, which is unnecessary for our
 // purposes here and could tickle problems w/ spurious lookups into ROOT meta
     PyObject* dct = PyObject_GetAttr(pyclass, PyStrings::gDict);
@@ -44,7 +44,7 @@ bool HasAttrDirect(PyObject* pyclass, PyObject* pyname, bool mustBeCPyCppyy = fa
         PyObject* attr = PyObject_GetItem(dct, pyname);
         Py_DECREF(dct);
         if (attr) {
-            bool ret = !mustBeCPyCppyy || CPPOverload_Check(attr);
+            bool ret = !mustBecpyrt || CPPOverload_Check(attr);
             Py_DECREF(attr);
             return ret;
         }
@@ -151,7 +151,7 @@ inline PyObject* CallSelfIndex(CPPInstance* self, PyObject* idx, PyObject* pymet
 //- "smart pointer" behavior ---------------------------------------------------
 static PyObject* smart_follow(PyObject* self, PyObject* name, PyObject* method)
 {
-    if (!CPyCppyy_PyText_Check(name))
+    if (!cpyrt_PyText_Check(name))
         PyErr_SetString(PyExc_TypeError, "getattr(): attribute name must be string");
 
     PyObject* pyptr = PyObject_CallMethodNoArgs(self, method);
@@ -163,7 +163,7 @@ static PyObject* smart_follow(PyObject* self, PyObject* name, PyObject* method)
         PyObject* val1 = PyObject_Str((PyObject*)Py_TYPE(self));
         PyObject* val2 = PyObject_Str(name);
         PyErr_Format(PyExc_AttributeError, "%s object has no attribute \'%s\'",
-            CPyCppyy_PyText_AsString(val1), CPyCppyy_PyText_AsString(val2));
+            cpyrt_PyText_AsString(val1), cpyrt_PyText_AsString(val2));
         Py_DECREF(val2);
         Py_DECREF(val1);
 
@@ -184,7 +184,7 @@ PyObject* DeRefGetAttr(PyObject* self, PyObject* name)
     // TODO: these calls come from TemplateProxy and are unlikely to be needed in practice,
     // whereas as-is, they can accidentally dereference the result of end() on some STL
     // containers. Obviously, this is a dumb hack that should be resolved more fundamentally.
-        PyErr_SetString(PyExc_AttributeError, CPyCppyy_PyText_AsString(name));
+        PyErr_SetString(PyExc_AttributeError, cpyrt_PyText_AsString(name));
         return nullptr;
     }
 
@@ -283,7 +283,7 @@ static ItemGetter* GetGetter(PyObject* args)
 
     if (PyTuple_GET_SIZE(args) == 1) {
         PyObject* fi = PyTuple_GET_ITEM(args, 0);
-        if (CPyCppyy_PyText_Check(fi) || PyBytes_Check(fi))
+        if (cpyrt_PyText_Check(fi) || PyBytes_Check(fi))
             return nullptr;       // do not accept string to fill std::vector<char>
 
     // TODO: this only tests for new-style buffers, which is too strict, but a
@@ -337,7 +337,7 @@ static bool FillVector(PyObject* vecin, PyObject* args, ItemGetter* getter)
         bool value_is_vector = false;
         if (vtype && PyLong_Check(vtype)) {
         // if the value_type is a vector, then allow for initialization from sequences
-            if (Cppyy::GetTypeAsString(PyLong_AsVoidPtr(vtype)).rfind("std::vector", 0) != std::string::npos)
+            if (cppjit::interop::GetTypeAsString(PyLong_AsVoidPtr(vtype)).rfind("std::vector", 0) != std::string::npos)
                 value_is_vector = true;
         } else
             PyErr_Clear();
@@ -439,7 +439,7 @@ PyObject* VectorIAdd(PyObject* self, PyObject* args, PyObject* /* kwds */)
 // a buffer here is slow, so use insert() instead
     if (PyTuple_GET_SIZE(args) == 1) {
         PyObject* fi = PyTuple_GET_ITEM(args, 0);
-        if (PyObject_CheckBuffer(fi) && !(CPyCppyy_PyText_Check(fi) || PyBytes_Check(fi))) {
+        if (PyObject_CheckBuffer(fi) && !(cpyrt_PyText_Check(fi) || PyBytes_Check(fi))) {
             PyObject* vend = PyObject_CallMethodNoArgs(self, PyStrings::gEnd);
             if (vend) {
                 PyObject* result = PyObject_CallMethodObjArgs(self, PyStrings::gInsert, vend, fi, nullptr);
@@ -564,36 +564,36 @@ static PyObject* vector_iter(PyObject* v) {
         }
 
         if (PyLong_Check(pyvalue_type)) {
-            Cppyy::TCppType_t value_type = PyLong_AsVoidPtr(pyvalue_type);
-            value_type = Cppyy::ResolveType(value_type);
-            vi->vi_klass = Cppyy::GetScopeFromType(value_type);
+            cppjit::interop::TCppType_t value_type = PyLong_AsVoidPtr(pyvalue_type);
+            value_type = cppjit::interop::ResolveType(value_type);
+            vi->vi_klass = cppjit::interop::GetScopeFromType(value_type);
             if (!vi->vi_klass) {
             // look for a special case of pointer to a class type (which is a builtin, but it
             // is more useful to treat it polymorphically by allowing auto-downcasts)
-                const std::string& clean_type = TypeManip::clean_type(Cppyy::GetTypeAsString(value_type), false, false);
-                Cppyy::TCppScope_t c = Cppyy::GetScope(clean_type);
-                if (c && TypeManip::compound(Cppyy::GetTypeAsString(value_type)) == "*") {
+                const std::string& clean_type = TypeManip::clean_type(cppjit::interop::GetTypeAsString(value_type), false, false);
+                cppjit::interop::TCppScope_t c = cppjit::interop::GetScope(clean_type);
+                if (c && TypeManip::compound(cppjit::interop::GetTypeAsString(value_type)) == "*") {
                     vi->vi_klass = c;
                     vi->vi_flags = vectoriterobject::kIsPolymorphic;
                 }
             }
-            if (Cppyy::IsPointerType(value_type))
+            if (cppjit::interop::IsPointerType(value_type))
                 vi->vi_flags = vectoriterobject::kIsPolymorphic;
             if (vi->vi_klass) {
                 vi->vi_converter = nullptr;
                 if (!vi->vi_flags) {
-                    value_type = Cppyy::ResolveType(value_type);
-                    if (Cppyy::GetTypeAsString(value_type).back() != '*')     // meaning, object stored by-value
+                    value_type = cppjit::interop::ResolveType(value_type);
+                    if (cppjit::interop::GetTypeAsString(value_type).back() != '*')     // meaning, object stored by-value
                         vi->vi_flags = vectoriterobject::kNeedLifeLine;
                 }
             } else
-                vi->vi_converter = CPyCppyy::CreateConverter(value_type);
-            if (!vi->vi_stride) vi->vi_stride = Cppyy::SizeOfType(value_type);
+                vi->vi_converter = cppjit::cpyrt::CreateConverter(value_type);
+            if (!vi->vi_stride) vi->vi_stride = cppjit::interop::SizeOfType(value_type);
 
         } else if (CPPScope_Check(pyvalue_type)) {
             vi->vi_klass = ((CPPClass*)pyvalue_type)->fCppType;
             vi->vi_converter = nullptr;
-            if (!vi->vi_stride) vi->vi_stride = Cppyy::SizeOf(vi->vi_klass);
+            if (!vi->vi_stride) vi->vi_stride = cppjit::interop::SizeOf(vi->vi_klass);
             if (!vi->vi_flags)  vi->vi_flags  = vectoriterobject::kNeedLifeLine;
         }
 
@@ -633,7 +633,7 @@ PyObject* VectorGetItem(CPPInstance* self, PySliceObject* index)
         PyObject* nseq = PyObject_CallObject(pyclass, nullptr);
 
         Py_ssize_t start, stop, step;
-        PySlice_GetIndices((CPyCppyy_PySliceCast)index, PyObject_Length((PyObject*)self), &start, &stop, &step);
+        PySlice_GetIndices((cpyrt_PySliceCast)index, PyObject_Length((PyObject*)self), &start, &stop, &step);
 
         const Py_ssize_t nlen = PySequence_Size((PyObject*)self);
         if (!AdjustSlice(nlen, start, stop, step))
@@ -655,7 +655,7 @@ PyObject* VectorGetItem(CPPInstance* self, PySliceObject* index)
 }
 
 
-static Cppyy::TCppScope_t sVectorBoolTypeID;
+static cppjit::interop::TCppScope_t sVectorBoolTypeID;
 
 PyObject* VectorBoolGetItem(CPPInstance* self, PyObject* idx)
 {
@@ -664,7 +664,7 @@ PyObject* VectorBoolGetItem(CPPInstance* self, PyObject* idx)
     if (!CPPInstance_Check(self) || self->ObjectIsA() != sVectorBoolTypeID) {
         PyErr_Format(PyExc_TypeError,
             "require object of type std::vector<bool>, but %s given",
-            Cppyy::GetScopedFinalName(self->ObjectIsA()).c_str());
+            cppjit::interop::GetScopedFinalName(self->ObjectIsA()).c_str());
         return nullptr;
     }
 
@@ -678,7 +678,7 @@ PyObject* VectorBoolGetItem(CPPInstance* self, PyObject* idx)
         PyObject* nseq = PyObject_CallObject(pyclass, nullptr);
 
         Py_ssize_t start, stop, step;
-        PySlice_GetIndices((CPyCppyy_PySliceCast)idx, PyObject_Length((PyObject*)self), &start, &stop, &step);
+        PySlice_GetIndices((cpyrt_PySliceCast)idx, PyObject_Length((PyObject*)self), &start, &stop, &step);
         const Py_ssize_t nlen = PySequence_Size((PyObject*)self);
         if (!AdjustSlice(nlen, start, stop, step))
             return nseq;
@@ -718,7 +718,7 @@ PyObject* VectorBoolSetItem(CPPInstance* self, PyObject* args)
     if (!CPPInstance_Check(self) || self->ObjectIsA() != sVectorBoolTypeID) {
         PyErr_Format(PyExc_TypeError,
             "require object of type std::vector<bool>, but %s given",
-            Cppyy::GetScopedFinalName(self->ObjectIsA()).c_str());
+            cppjit::interop::GetScopedFinalName(self->ObjectIsA()).c_str());
         return nullptr;
     }
 
@@ -1004,7 +1004,7 @@ PyObject* STLSequenceIter(PyObject* self)
                 if (!PyIter_Check(iter)) {   // no tp_iternext, or the
                                              // _PyObject_NextNotImplemented sentinel
                     itype->tp_iternext = (iternextfunc)STLIterNext;
-                    Utility::AddToClass((PyObject*)itype, CPPYY__next__,
+                    Utility::AddToClass((PyObject*)itype, CPPJIT__next__,
                                         (PyCFunction)STLIterNext, METH_NOARGS);
                     if (!itype->tp_iter) {
                         itype->tp_iter = (getiterfunc)PyObject_SelfIter;
@@ -1133,14 +1133,14 @@ static int PyObject_Compare(PyObject* one, PyObject* other) {
     return !PyObject_RichCompareBool(one, other, Py_EQ);
 }
 static inline
-PyObject* CPyCppyy_PyString_FromCppString(std::string_view s, bool native=true) {
+PyObject* cpyrt_PyString_FromCppString(std::string_view s, bool native=true) {
     if (native)
         return PyBytes_FromStringAndSize(s.data(), s.size());
-    return CPyCppyy_PyText_FromStringAndSize(s.data(), s.size());
+    return cpyrt_PyText_FromStringAndSize(s.data(), s.size());
 }
 
 static inline
-PyObject* CPyCppyy_PyString_FromCppString(std::wstring_view s, bool native=true) {
+PyObject* cpyrt_PyString_FromCppString(std::wstring_view s, bool native=true) {
     PyObject* pyobj = PyUnicode_FromWideChar(s.data(), s.size());
     if (pyobj && native) {
         PyObject* pybytes = PyUnicode_AsEncodedString(pyobj, "UTF-8", "strict");
@@ -1150,13 +1150,13 @@ PyObject* CPyCppyy_PyString_FromCppString(std::wstring_view s, bool native=true)
     return pyobj;
 }
 
-#define CPPYY_IMPL_STRING_PYTHONIZATION(type, name)                          \
+#define CPPJIT_IMPL_STRING_PYTHONIZATION(type, name)                          \
 static inline                                                                \
 PyObject* name##StringGetData(PyObject* self, bool native=true)              \
 {                                                                            \
-    if (CPyCppyy::CPPInstance_Check(self)) {                                 \
+    if (cppjit::cpyrt::CPPInstance_Check(self)) {                                 \
         type* obj = ((type*)((CPPInstance*)self)->GetObject());              \
-        if (obj) return CPyCppyy_PyString_FromCppString(*obj, native);        \
+        if (obj) return cpyrt_PyString_FromCppString(*obj, native);        \
     }                                                                        \
     PyErr_Format(PyExc_TypeError, "object mismatch (%s expected)", #type);   \
     return nullptr;                                                          \
@@ -1216,8 +1216,8 @@ PyObject* name##StringIsNotEqual(PyObject* self, PyObject* obj)              \
 }
 
 // Only define STLStringCompare:
-#define CPPYY_IMPL_STRING_PYTHONIZATION_CMP(type, name)                      \
-CPPYY_IMPL_STRING_PYTHONIZATION(type, name)                                  \
+#define CPPJIT_IMPL_STRING_PYTHONIZATION_CMP(type, name)                      \
+CPPJIT_IMPL_STRING_PYTHONIZATION(type, name)                                  \
 PyObject* name##StringCompare(PyObject* self, PyObject* obj)                 \
 {                                                                            \
     PyObject* data = name##StringGetData(self, PyBytes_Check(obj));          \
@@ -1231,9 +1231,9 @@ PyObject* name##StringCompare(PyObject* self, PyObject* obj)                 \
     return PyInt_FromLong(result);                                           \
 }
 
-CPPYY_IMPL_STRING_PYTHONIZATION_CMP(std::string, STL)
-CPPYY_IMPL_STRING_PYTHONIZATION_CMP(std::wstring, STLW)
-CPPYY_IMPL_STRING_PYTHONIZATION_CMP(std::string_view, STLView)
+CPPJIT_IMPL_STRING_PYTHONIZATION_CMP(std::string, STL)
+CPPJIT_IMPL_STRING_PYTHONIZATION_CMP(std::wstring, STLW)
+CPPJIT_IMPL_STRING_PYTHONIZATION_CMP(std::string_view, STLView)
 
 static inline std::string* GetSTLString(CPPInstance* self) {
     if (!CPPInstance_Check(self)) {
@@ -1269,7 +1269,7 @@ PyObject* STLStringContains(CPPInstance* self, PyObject* pyobj)
     if (!obj)
         return nullptr;
 
-    const char* needle = CPyCppyy_PyText_AsString(pyobj);
+    const char* needle = cpyrt_PyText_AsString(pyobj);
     if (!needle)
         return nullptr;
 
@@ -1290,8 +1290,8 @@ PyObject* STLStringReplace(CPPInstance* self, PyObject* args, PyObject* /*kwds*/
 // accepts strings and takes no keyword arguments, whereas the C++ version has no
 // overload that takes a string
 
-    if (2 <= PyTuple_GET_SIZE(args) && CPyCppyy_PyText_Check(PyTuple_GET_ITEM(args, 0))) {
-        PyObject* pystr = CPyCppyy_PyText_FromStringAndSize(obj->data(), obj->size());
+    if (2 <= PyTuple_GET_SIZE(args) && cpyrt_PyText_Check(PyTuple_GET_ITEM(args, 0))) {
+        PyObject* pystr = cpyrt_PyText_FromStringAndSize(obj->data(), obj->size());
         PyObject* meth = PyObject_GetAttrString(pystr, (char*)"replace");
         Py_DECREF(pystr);
         PyObject* result = PyObject_CallObject(meth, args);
@@ -1310,7 +1310,7 @@ PyObject* STLStringReplace(CPPInstance* self, PyObject* args, PyObject* /*kwds*/
     return nullptr;
 }
 
-#define CPYCPPYY_STRING_FINDMETHOD(name, cppname, pyname)                    \
+#define CPYRT_STRING_FINDMETHOD(name, cppname, pyname)                    \
 PyObject* STLString##name(CPPInstance* self, PyObject* args, PyObject* /*kwds*/) \
 {                                                                            \
     std::string* obj = GetSTLString(self);                                   \
@@ -1331,7 +1331,7 @@ PyObject* STLString##name(CPPInstance* self, PyObject* args, PyObject* /*kwds*/)
         PyErr_Clear();                                                       \
     }                                                                        \
                                                                              \
-    PyObject* pystr = CPyCppyy_PyText_FromStringAndSize(obj->data(), obj->size());\
+    PyObject* pystr = cpyrt_PyText_FromStringAndSize(obj->data(), obj->size());\
     PyObject* pymeth = PyObject_GetAttrString(pystr, (char*)#pyname);        \
     Py_DECREF(pystr);                                                        \
     PyObject* result = PyObject_CallObject(pymeth, args);                    \
@@ -1341,8 +1341,8 @@ PyObject* STLString##name(CPPInstance* self, PyObject* args, PyObject* /*kwds*/)
 
 // both str and std::string have method "find" and "rfin"; try the C++ version first
 // and fall back on the Python one in case of failure
-CPYCPPYY_STRING_FINDMETHOD( Find, __cpp_find,  find)
-CPYCPPYY_STRING_FINDMETHOD(RFind, __cpp_rfind, rfind)
+CPYRT_STRING_FINDMETHOD( Find, __cpp_find,  find)
+CPYRT_STRING_FINDMETHOD(RFind, __cpp_rfind, rfind)
 
 PyObject* STLStringGetAttr(CPPInstance* self, PyObject* attr_name)
 {
@@ -1350,7 +1350,7 @@ PyObject* STLStringGetAttr(CPPInstance* self, PyObject* attr_name)
     if (!obj)
         return nullptr;
 
-    PyObject* pystr = CPyCppyy_PyText_FromStringAndSize(obj->data(), obj->size());
+    PyObject* pystr = cpyrt_PyText_FromStringAndSize(obj->data(), obj->size());
     PyObject* attr = PyObject_GetAttr(pystr, attr_name);
     Py_DECREF(pystr);
     return attr;
@@ -1361,7 +1361,7 @@ PyObject* UTF8Repr(PyObject* self)
 {
 // force C++ string types conversion to Python str per Python __repr__ requirements
     PyObject* res = PyObject_CallMethodNoArgs(self, PyStrings::gCppRepr);
-    if (!res || CPyCppyy_PyText_Check(res))
+    if (!res || cpyrt_PyText_Check(res))
         return res;
     PyObject* str_res = PyObject_Str(res);
     Py_DECREF(res);
@@ -1372,7 +1372,7 @@ PyObject* UTF8Str(PyObject* self)
 {
 // force C++ string types conversion to Python str per Python __str__ requirements
     PyObject* res = PyObject_CallMethodNoArgs(self, PyStrings::gCppStr);
-    if (!res || CPyCppyy_PyText_Check(res))
+    if (!res || cpyrt_PyText_Check(res))
         return res;
     PyObject* str_res = PyObject_Str(res);
     Py_DECREF(res);
@@ -1384,7 +1384,7 @@ Py_hash_t STLStringHash(PyObject* self)
 // std::string objects hash to the same values as Python strings to allow
 // matches in dictionaries etc.
     PyObject* data = STLStringGetData(self, false);
-    Py_hash_t h = CPyCppyy_PyText_Type.tp_hash(data);
+    Py_hash_t h = cpyrt_PyText_Type.tp_hash(data);
     Py_DECREF(data);
     return h;
 }
@@ -1538,7 +1538,7 @@ static PyObject* ComplexRepr(PyObject* self) {
 
     std::ostringstream s;
     s << '(' << r << '+' << i << "j)";
-    return CPyCppyy_PyText_FromString(s.str().c_str());
+    return cpyrt_PyText_FromString(s.str().c_str());
 }
 
 static PyObject* ComplexDRealGet(CPPInstance* self, void*)
@@ -1586,7 +1586,7 @@ static PyObject* ComplexDComplex(CPPInstance* self)
 
 
 //- public functions ---------------------------------------------------------
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     std::set<std::string> gIteratorTypes;
 }
 
@@ -1611,9 +1611,9 @@ bool run_pythonizors(PyObject* pyclass, PyObject* pyname, const std::vector<PyOb
     return pstatus;
 }
 
-bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
+bool cppjit::cpyrt::Pythonize(PyObject* pyclass, cppjit::interop::TCppScope_t scope)
 {
-    const std::string& name = Cppyy::GetScopedFinalName(scope);
+    const std::string& name = cppjit::interop::GetScopedFinalName(scope);
 
 // Add pre-defined pythonizations (for STL and ROOT) to classes based on their
 // signature and/or class name.
@@ -1628,9 +1628,9 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
 // prefer operator-> as that returns a pointer (which is simpler since it never
 // has to deal with ref-assignment), but operator* plays better with STL iters
 // and algorithms
-    if (HasAttrDirect(pyclass, PyStrings::gDeref) && !Cppyy::IsSmartPtr(klass->fCppType))
+    if (HasAttrDirect(pyclass, PyStrings::gDeref) && !cppjit::interop::IsSmartPtr(klass->fCppType))
         Utility::AddToClass(pyclass, "__getattr__", (PyCFunction)DeRefGetAttr, METH_O);
-    else if (HasAttrDirect(pyclass, PyStrings::gFollow) && !Cppyy::IsSmartPtr(klass->fCppType))
+    else if (HasAttrDirect(pyclass, PyStrings::gFollow) && !cppjit::interop::IsSmartPtr(klass->fCppType))
         Utility::AddToClass(pyclass, "__getattr__", (PyCFunction)FollowGetAttr, METH_O);
 
 // for pre-check of nullptr for boolean types
@@ -1640,10 +1640,10 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
     }
 
 // for STL containers, and user classes modeled after them
-// the attribute must be a CPyCppyy overload, otherwise the check gives false
+// the attribute must be a cpyrt overload, otherwise the check gives false
 // positives in the case where the class has a non-function attribute that is
 // called "size".
-    if (HasAttrDirect(pyclass, PyStrings::gSize, /*mustBeCPyCppyy=*/ true)) {
+    if (HasAttrDirect(pyclass, PyStrings::gSize, /*mustBecpyrt=*/ true)) {
         Utility::AddToClass(pyclass, "__len__", "size");
     }
 
@@ -1655,14 +1655,14 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
            !((PyTypeObject*)pyclass)->tp_iter) {
         if (HasAttrDirect(pyclass, PyStrings::gBegin) && HasAttrDirect(pyclass, PyStrings::gEnd)) {
         // obtain the name of the return type
-            const auto& methods = Cppyy::GetMethodsFromName(klass->fCppType, "begin");
+            const auto& methods = cppjit::interop::GetMethodsFromName(klass->fCppType, "begin");
             if (!methods.empty()) {
             // check return type; if not explicitly an iterator, add it to the "known" return
             // types to add the "next" method on use
-                Cppyy::TCppMethod_t meth = methods[0];
-                const std::string& resname = Cppyy::GetMethodReturnTypeAsString(meth);
+                cppjit::interop::TCppMethod_t meth = methods[0];
+                const std::string& resname = cppjit::interop::GetMethodReturnTypeAsString(meth);
                 bool isIterator = gIteratorTypes.find(resname) != gIteratorTypes.end();
-                if (!isIterator && Cppyy::GetScope(resname)) {
+                if (!isIterator && cppjit::interop::GetScope(resname)) {
                     if (resname.find("iterator") == std::string::npos)
                         gIteratorTypes.insert(resname);
                     isIterator = true;
@@ -1675,8 +1675,8 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
                 } else {
                 // still okay if this is some pointer type of builtin persuasion (general class
                 // won't work: the return type needs to understand the iterator protocol)
-                    std::string resolved = Cppyy::ResolveName(resname);
-                    if (resolved.back() == '*' && Cppyy::IsBuiltin(resolved.substr(0, resolved.size()-1))) {
+                    std::string resolved = cppjit::interop::ResolveName(resname);
+                    if (resolved.back() == '*' && cppjit::interop::IsBuiltin(resolved.substr(0, resolved.size()-1))) {
                         ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)LLSequenceIter;
                         Utility::AddToClass(pyclass, "__iter__", (PyCFunction)LLSequenceIter, METH_NOARGS);
                     }
@@ -1698,7 +1698,7 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
 // comparisons to None; if no operator is available, a hook is installed for lazy
 // lookups in the global and/or class namespace
     if (HasAttrDirect(pyclass, PyStrings::gEq, true) && \
-            Cppyy::GetMethodsFromName(klass->fCppType, "__eq__").empty()) {
+            cppjit::interop::GetMethodsFromName(klass->fCppType, "__eq__").empty()) {
         PyObject* cppol = PyObject_GetAttr(pyclass, PyStrings::gEq);
         if (!klass->fOperators) klass->fOperators = new Utility::PyOperators();
         klass->fOperators->fEq = cppol;
@@ -1715,7 +1715,7 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
     }
 
     if (HasAttrDirect(pyclass, PyStrings::gNe, true) && \
-            Cppyy::GetMethodsFromName(klass->fCppType, "__ne__").empty()) {
+            cppjit::interop::GetMethodsFromName(klass->fCppType, "__ne__").empty()) {
         PyObject* cppol = PyObject_GetAttr(pyclass, PyStrings::gNe);
         if (!klass->fOperators) klass->fOperators = new Utility::PyOperators();
         klass->fOperators->fNe = cppol;
@@ -1742,34 +1742,34 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
         Utility::AddToClass(pyclass, "__str__", (PyCFunction)UTF8Str, METH_NOARGS);
     }
 
-    if (Cppyy::IsAggregate(((CPPClass*)pyclass)->fCppType) && name.compare(0, 5, "std::", 5) != 0) {
+    if (cppjit::interop::IsAggregate(((CPPClass*)pyclass)->fCppType) && name.compare(0, 5, "std::", 5) != 0) {
     // create a pseudo-constructor to allow initializer-style object creation
-        Cppyy::TCppScope_t kls = ((CPPClass*)pyclass)->fCppType;
-        std::vector<Cppyy::TCppScope_t> datamems;
-        Cppyy::GetDatamembers(kls, datamems);
+        cppjit::interop::TCppScope_t kls = ((CPPClass*)pyclass)->fCppType;
+        std::vector<cppjit::interop::TCppScope_t> datamems;
+        cppjit::interop::GetDatamembers(kls, datamems);
         if (!datamems.empty()) {
             std::string rname = name;
             TypeManip::cppscope_to_legalname(rname);
 
             std::ostringstream initdef;
-            initdef << "namespace __cppyy_internal {\n"
+            initdef << "namespace __cppjit_internal {\n"
                     << "void init_" << rname << "(" << name << "** self";
             bool codegen_ok = true;
             std::vector<std::string> arg_types, arg_names, arg_defaults;
             const int ndata = datamems.size();
             arg_types.reserve(ndata); arg_names.reserve(ndata); arg_defaults.reserve(ndata);
             for (auto data : datamems) {
-                if (Cppyy::IsStaticDatamember(data) || !Cppyy::IsPublicData(data))
+                if (cppjit::interop::IsStaticDatamember(data) || !cppjit::interop::IsPublicData(data))
                     continue;
 
-                Cppyy::TCppType_t datammember_type =
-                    Cppyy::GetDatamemberType(data);
+                cppjit::interop::TCppType_t datammember_type =
+                    cppjit::interop::GetDatamemberType(data);
                 const std::string &res =
-                    Cppyy::IsEnumType(datammember_type)
-                        ? Cppyy::GetScopedFinalName(
-                              Cppyy::GetScopeFromType(datammember_type))
-                        : Cppyy::GetTypeAsString(
-                              Cppyy::ResolveType(datammember_type));
+                    cppjit::interop::IsEnumType(datammember_type)
+                        ? cppjit::interop::GetScopedFinalName(
+                              cppjit::interop::GetScopeFromType(datammember_type))
+                        : cppjit::interop::GetTypeAsString(
+                              cppjit::interop::ResolveType(datammember_type));
                 const std::string& cpd = TypeManip::compound(res);
                 std::string res_clean = TypeManip::clean_type(res, false, true);
 
@@ -1779,12 +1779,12 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
                 if (res.rfind(']') == std::string::npos && res.rfind(')') == std::string::npos) {
                     if (!cpd.empty()) arg_types.push_back(res_clean+cpd);
                     else arg_types.push_back("const "+res_clean+"&");
-                    arg_names.push_back(Cppyy::GetFinalName(data));
-                    if ((!cpd.empty() && cpd.back() == '*') || Cppyy::IsBuiltin(res_clean))
+                    arg_names.push_back(cppjit::interop::GetFinalName(data));
+                    if ((!cpd.empty() && cpd.back() == '*') || cppjit::interop::IsBuiltin(res_clean))
                         arg_defaults.push_back("0");
                     else {
-                        Cppyy::TCppScope_t klsid = Cppyy::GetScope(res_clean);
-                        if (Cppyy::IsDefaultConstructable(klsid)) arg_defaults.push_back(res_clean+"{}");
+                        cppjit::interop::TCppScope_t klsid = cppjit::interop::GetScope(res_clean);
+                        if (cppjit::interop::IsDefaultConstructable(klsid)) arg_defaults.push_back(res_clean+"{}");
                     }
                 } else {
                     codegen_ok = false;     // TODO: how to support arrays, anonymous enums, etc?
@@ -1805,9 +1805,9 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
                 }
                 initdef << "};\n} }";
 
-                if (Cppyy::Compile(initdef.str(), true /* silent */)) {
-                    Cppyy::TCppScope_t cis = Cppyy::GetScope("__cppyy_internal");
-                    const auto& methods = Cppyy::GetMethodsFromName(cis, "init_" + rname);
+                if (cppjit::interop::Compile(initdef.str(), true /* silent */)) {
+                    cppjit::interop::TCppScope_t cis = cppjit::interop::GetScope("__cppjit_internal");
+                    const auto& methods = cppjit::interop::GetMethodsFromName(cis, "init_" + rname);
                     if (methods.size()) {
                         if (!Utility::AddToClass(pyclass, "__init__",
                                 new CPPFunction(cis, methods[0])))
@@ -1824,7 +1824,7 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
     if (IsTemplatedSTLClass(name, "vector")) {
 
     // std::vector<bool> is a special case in C++
-        if (!sVectorBoolTypeID) sVectorBoolTypeID = Cppyy::GetScope("std::vector<bool>");
+        if (!sVectorBoolTypeID) sVectorBoolTypeID = cppjit::interop::GetScope("std::vector<bool>");
         if (klass->fCppType == sVectorBoolTypeID) {
             Utility::AddToClass(pyclass, "__getitem__", (PyCFunction)VectorBoolGetItem, METH_O);
             Utility::AddToClass(pyclass, "__setitem__", (PyCFunction)VectorBoolSetItem);
@@ -1853,18 +1853,18 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
             Utility::AddToClass(pyclass, "__iadd__", (PyCFunction)VectorIAdd, METH_VARARGS | METH_KEYWORDS);
 
         // helpers for iteration
-            Cppyy::TCppType_t value_type = Cppyy::GetTypeFromScope(Cppyy::GetNamed("value_type", scope));
-            Cppyy::TCppType_t vtype = Cppyy::ResolveType(value_type);
+            cppjit::interop::TCppType_t value_type = cppjit::interop::GetTypeFromScope(cppjit::interop::GetNamed("value_type", scope));
+            cppjit::interop::TCppType_t vtype = cppjit::interop::ResolveType(value_type);
             if (vtype) {    // actually resolved?
                 PyObject* pyvalue_type = PyLong_FromVoidPtr(vtype.data);
                 PyObject_SetAttr(pyclass, PyStrings::gValueTypePtr, pyvalue_type);
                 Py_DECREF(pyvalue_type);
-                pyvalue_type = PyUnicode_FromString(Cppyy::GetTypeAsString(vtype).c_str());
+                pyvalue_type = PyUnicode_FromString(cppjit::interop::GetTypeAsString(vtype).c_str());
                 PyObject_SetAttr(pyclass, PyStrings::gValueType, pyvalue_type);
                 Py_DECREF(pyvalue_type);
             }
 
-            size_t typesz = Cppyy::SizeOfType(vtype);
+            size_t typesz = cppjit::interop::SizeOfType(vtype);
             if (typesz) {
                 PyObject* pyvalue_size = PyLong_FromSsize_t(typesz);
                 PyObject_SetAttr(pyclass, PyStrings::gValueSize, pyvalue_size);
@@ -1916,7 +1916,7 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
     else if (!((PyTypeObject*)pyclass)->tp_iter && \
              (name.find("iterator") != std::string::npos || gIteratorTypes.find(name) != gIteratorTypes.end())) {
         ((PyTypeObject*)pyclass)->tp_iternext = (iternextfunc)STLIterNext;
-        Utility::AddToClass(pyclass, CPPYY__next__, (PyCFunction)STLIterNext, METH_NOARGS);
+        Utility::AddToClass(pyclass, CPPJIT__next__, (PyCFunction)STLIterNext, METH_NOARGS);
         ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)PyObject_SelfIter;
         Utility::AddToClass(pyclass, "__iter__", (PyCFunction)PyObject_SelfIter, METH_NOARGS);
     }
@@ -1931,7 +1931,7 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
         Utility::AddToClass(pyclass, "__eq__",        (PyCFunction)STLStringIsEqual,    METH_O);
         Utility::AddToClass(pyclass, "__ne__",        (PyCFunction)STLStringIsNotEqual, METH_O);
     // Python's `in` operator needs __contains__ on the proxy regardless of the
-    // C++ standard CPyCppyy is built with; it never dispatches to C++'s
+    // C++ standard cpyrt is built with; it never dispatches to C++'s
     // std::string::contains (C++23+). The old `__cplusplus <= 202302L` guard
     // wrongly dropped it when built with -std=c++2c (__cplusplus == 202400L).
         Utility::AddToClass(pyclass, "__contains__",  (PyCFunction)STLStringContains,   METH_O);
@@ -1994,7 +1994,7 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
 //   - explicit pythonization: won't fall through to the base classes and is preferred if present
 //   - normal pythonization: only called if explicit isn't present, falls through to base classes
     bool bUserOk = true; PyObject* res = nullptr;
-    PyObject* pyname = CPyCppyy_PyText_FromString(name.c_str());
+    PyObject* pyname = cpyrt_PyText_FromString(name.c_str());
     if (HasAttrDirect(pyclass, PyStrings::gExPythonize)) {
         res = PyObject_CallMethodObjArgs(pyclass, PyStrings::gExPythonize, pyclass, pyname, nullptr);
         bUserOk = (bool)res;
@@ -2023,7 +2023,7 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, Cppyy::TCppScope_t scope)
     if (!outer_scope.empty()) {
         auto p = pyzMap.find(outer_scope);
         if (p != pyzMap.end()) {
-            PyObject* subname = CPyCppyy_PyText_FromString(
+            PyObject* subname = cpyrt_PyText_FromString(
                 name.substr(outer_scope.size()+2, std::string::npos).c_str());
             pstatus = run_pythonizors(pyclass, subname, p->second);
             Py_DECREF(subname);
diff --git a/src/cpyrt/Pythonize.h b/src/cpyrt/Pythonize.h
new file mode 100644
index 0000000..5f592b5
--- /dev/null
+++ b/src/cpyrt/Pythonize.h
@@ -0,0 +1,15 @@
+#ifndef CPYRT_PYTHONIZE_H
+#define CPYRT_PYTHONIZE_H
+
+// Standard
+#include <string>
+
+
+namespace cppjit::cpyrt {
+
+// make the named C++ class more python-like
+bool Pythonize(PyObject* pyclass, cppjit::interop::TCppScope_t scope);
+
+} // namespace cppjit::cpyrt
+
+#endif // !CPYRT_PYTHONIZE_H
diff --git a/src/CPyCppyy/include/CPyCppyy/Reflex.h b/src/cpyrt/Reflex.h
similarity index 78%
rename from src/CPyCppyy/include/CPyCppyy/Reflex.h
rename to src/cpyrt/Reflex.h
index b37b9ee..3365278 100644
--- a/src/CPyCppyy/include/CPyCppyy/Reflex.h
+++ b/src/cpyrt/Reflex.h
@@ -1,11 +1,11 @@
-#ifndef CPYCPPYY_REFLEX_H
-#define CPYCPPYY_REFLEX_H
+#ifndef CPYRT_REFLEX_H
+#define CPYRT_REFLEX_H
 
 //
 // Access to the C++ reflection information
 //
 
-namespace Cppyy {
+namespace cppjit::interop {
 
 namespace Reflex {
 
@@ -25,6 +25,6 @@ const FormatId_t AS_STRING        =  3;
 
 } // namespace Reflex
 
-} // namespace Cppyy
+} // namespace cppjit::interop
 
-#endif // !CPYCPPYY_REFLEX_H
+#endif // !CPYRT_REFLEX_H
diff --git a/src/CPyCppyy/src/SignalTryCatch.h b/src/cpyrt/SignalTryCatch.h
similarity index 70%
rename from src/CPyCppyy/src/SignalTryCatch.h
rename to src/cpyrt/SignalTryCatch.h
index 14742b8..21a5a0f 100644
--- a/src/CPyCppyy/src/SignalTryCatch.h
+++ b/src/cpyrt/SignalTryCatch.h
@@ -8,11 +8,11 @@
  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
  *************************************************************************/
 
-#ifndef CPYCPPYY_SIGNALTRYCATCH_H
-#define CPYCPPYY_SIGNALTRYCATCH_H
+#ifndef CPYRT_SIGNALTRYCATCH_H
+#define CPYRT_SIGNALTRYCATCH_H
 
 #include <setjmp.h>
-#include "CPyCppyy/CommonDefs.h"
+#include "cpyrt/CommonDefs.h"
 
 #ifndef _WIN32
 #define NEED_SIGJMP 1
@@ -20,9 +20,9 @@
 
 // By default, the ExceptionContext_t class is expected in the namespace
 // CppyyLegacy, If it is expected in no namespace, one can explicitly define
-// NO_CPPYY_LEGACY_NAMESPACE at build time (e.g. if one wants to use ROOT).
+// NO_CPPJIT_LEGACY_NAMESPACE at build time (e.g. if one wants to use ROOT).
 
-#ifndef NO_CPPYY_LEGACY_NAMESPACE
+#ifndef NO_CPPJIT_LEGACY_NAMESPACE
 namespace CppyyLegacy {
 #endif
 struct ExceptionContext_t {
@@ -32,17 +32,17 @@ struct ExceptionContext_t {
     jmp_buf fBuf;
 #endif
 };
-#ifndef NO_CPPYY_LEGACY_NAMESPACE
+#ifndef NO_CPPJIT_LEGACY_NAMESPACE
 }
 
-using CppyyExceptionContext_t = CppyyLegacy::ExceptionContext_t;
+using cppjit_interopExceptionContext_t = CppyyLegacy::ExceptionContext_t;
 #else
-using CppyyExceptionContext_t = ExceptionContext_t;
+using cppjit_interopExceptionContext_t = ExceptionContext_t;
 #endif
 
 // FIXME: This is a dummy, replace with cling equivalent of gException
-static CppyyExceptionContext_t DummyException;
-static CppyyExceptionContext_t *gException = &DummyException;
+static cppjit_interopExceptionContext_t DummyException;
+static cppjit_interopExceptionContext_t *gException = &DummyException;
 
 #ifdef NEED_SIGJMP
 # define CLING_EXCEPTION_SETJMP(buf) sigsetjmp(buf,1)
@@ -52,14 +52,14 @@ static CppyyExceptionContext_t *gException = &DummyException;
 
 #define CLING_EXCEPTION_RETRY \
     { \
-        static CppyyExceptionContext_t R__curr, *R__old = gException; \
+        static cppjit_interopExceptionContext_t R__curr, *R__old = gException; \
         int R__code; \
         gException = &R__curr; \
         R__code = CLING_EXCEPTION_SETJMP(gException->fBuf); if (R__code) { }; {
 
 #define CLING_EXCEPTION_TRY \
     { \
-        static CppyyExceptionContext_t R__curr, *R__old = gException; \
+        static cppjit_interopExceptionContext_t R__curr, *R__old = gException; \
         int R__code; \
         gException = &R__curr; \
         if ((R__code = CLING_EXCEPTION_SETJMP(gException->fBuf)) == 0) {
@@ -75,6 +75,6 @@ static CppyyExceptionContext_t *gException = &DummyException;
         gException = R__old; \
     }
 
-CPYCPPYY_IMPORT CppyyExceptionContext_t *gException;
+CPYRT_IMPORT cppjit_interopExceptionContext_t *gException;
 
 #endif
diff --git a/src/CPyCppyy/src/TemplateProxy.cxx b/src/cpyrt/TemplateProxy.cxx
similarity index 89%
rename from src/CPyCppyy/src/TemplateProxy.cxx
rename to src/cpyrt/TemplateProxy.cxx
index b42a1b0..631cc3d 100644
--- a/src/CPyCppyy/src/TemplateProxy.cxx
+++ b/src/cpyrt/TemplateProxy.cxx
@@ -1,12 +1,12 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "TemplateProxy.h"
 #include "CPPClassMethod.h"
 #include "CPPConstructor.h"
 #include "CPPFunction.h"
 #include "CPPMethod.h"
 #include "CPPOverload.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "PyCallable.h"
 #include "PyStrings.h"
 #include "Utility.h"
@@ -15,12 +15,12 @@
 #include <algorithm>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 static inline std::string targs2str(TemplateProxy* pytmpl)
 {
     if (!pytmpl || !pytmpl->fTemplateArgs) return "";
-    return CPyCppyy_PyText_AsString(pytmpl->fTemplateArgs);
+    return cpyrt_PyText_AsString(pytmpl->fTemplateArgs);
 }
 
 //----------------------------------------------------------------------------
@@ -77,25 +77,25 @@ void TemplateProxy::AdoptTemplate(PyCallable* pc)
 
 //----------------------------------------------------------------------------
 PyObject* TemplateProxy::Instantiate(const std::string& fname,
-    CPyCppyy_PyArgs_t args, size_t nargsf, Utility::ArgPreference pref, int* pcnt)
+    cpyrt_PyArgs_t args, size_t nargsf, Utility::ArgPreference pref, int* pcnt)
 {
 // Instantiate (and cache) templated methods, return method if any
     std::string proto = "";
 
 // adjust arguments for self if this is a rebound global function
     bool isNS = (((CPPScope*)fTI->fPyClass)->fFlags & CPPScope::kIsNamespace);
-    if (!isNS && CPyCppyy_PyArgs_GET_SIZE(args, nargsf) && \
+    if (!isNS && cpyrt_PyArgs_GET_SIZE(args, nargsf) && \
             (!fSelf ||
-            (fSelf == Py_None && !Cppyy::IsStaticTemplate(((CPPScope*)fTI->fPyClass)->fCppType, fname)))) {
+            (fSelf == Py_None && !cppjit::interop::IsStaticTemplate(((CPPScope*)fTI->fPyClass)->fCppType, fname)))) {
         args   += 1;
         nargsf -= 1;
     }
 
-    Py_ssize_t argc = CPyCppyy_PyArgs_GET_SIZE(args, nargsf);
+    Py_ssize_t argc = cpyrt_PyArgs_GET_SIZE(args, nargsf);
     if (argc != 0) {
         PyObject* tpArgs = PyTuple_New(argc);
         for (Py_ssize_t i = 0; i < argc; ++i) {
-            PyObject* itemi = CPyCppyy_PyArgs_GET_ITEM(args, i);
+            PyObject* itemi = cpyrt_PyArgs_GET_ITEM(args, i);
 
             bool bArgSet = false;
 
@@ -164,7 +164,7 @@ PyObject* TemplateProxy::Instantiate(const std::string& fname,
 
         PyObject* pyargs = PyTuple_New(argc);
         for (Py_ssize_t i = 0; i < argc; ++i) {
-            PyObject* item = CPyCppyy_PyArgs_GET_ITEM(args, i);
+            PyObject* item = cpyrt_PyArgs_GET_ITEM(args, i);
             Py_INCREF(item);
             PyTuple_SET_ITEM(pyargs, i, item);
         }
@@ -185,8 +185,8 @@ PyObject* TemplateProxy::Instantiate(const std::string& fname,
     }
 
 // the following causes instantiation as necessary
-    Cppyy::TCppScope_t scope = ((CPPClass*)fTI->fPyClass)->fCppType;
-    Cppyy::TCppMethod_t cppmeth = Cppyy::GetMethodTemplate(scope, fname, proto);
+    cppjit::interop::TCppScope_t scope = ((CPPClass*)fTI->fPyClass)->fCppType;
+    cppjit::interop::TCppMethod_t cppmeth = cppjit::interop::GetMethodTemplate(scope, fname, proto);
     if (cppmeth) {    // overload stops here
     // A successful instantiation needs to be cached to pre-empt future instantiations. There
     // are two names involved, the original asked (which may be partial) and the received.
@@ -199,7 +199,7 @@ PyObject* TemplateProxy::Instantiate(const std::string& fname,
     // TODO: this caches the lookup method before the call, meaning that failing overloads
     // can add already existing overloads to the set of methods.
 
-        std::string resname = Cppyy::GetFullName(Cppyy::TCppScope_t(cppmeth.data));
+        std::string resname = cppjit::interop::GetFullName(cppjit::interop::TCppScope_t(cppmeth.data));
 
     // An initializer_list is preferred for the argument types, but should not leak into
     // the argument types. If it did, replace with vector and lookup anew.
@@ -210,12 +210,12 @@ PyObject* TemplateProxy::Instantiate(const std::string& fname,
                 pos = proto.find("initializer_list", pos + 6);
             }
 
-            Cppyy::TCppMethod_t m2 = Cppyy::GetMethodTemplate(scope, fname, proto);
+            cppjit::interop::TCppMethod_t m2 = cppjit::interop::GetMethodTemplate(scope, fname, proto);
             if (m2 && m2 != cppmeth) {
             // replace if the new method with vector was found; otherwise just continue
             // with the previously found method with initializer_list.
                 cppmeth = m2;
-                resname = Cppyy::GetFullName(Cppyy::TCppScope_t(cppmeth.data));
+                resname = cppjit::interop::GetFullName(cppjit::interop::TCppScope_t(cppmeth.data));
             }
         }
 
@@ -223,7 +223,7 @@ PyObject* TemplateProxy::Instantiate(const std::string& fname,
 
     // lookup on existing name in case this was an overload, not a caching, failure
         PyObject* dct = PyObject_GetAttr(fTI->fPyClass, PyStrings::gDict);
-        PyObject* pycachename = CPyCppyy_PyText_InternFromString(fname.c_str());
+        PyObject* pycachename = cpyrt_PyText_InternFromString(fname.c_str());
         PyObject* pyol = PyObject_GetItem(dct, pycachename);
         if (!pyol) PyErr_Clear();
         bool bIsCppOL = CPPOverload_Check(pyol);
@@ -231,7 +231,7 @@ PyObject* TemplateProxy::Instantiate(const std::string& fname,
 
     // find the full name if the requested one was partial
         PyObject* exact = nullptr;
-        PyObject* pyresname = CPyCppyy_PyText_FromString(resname.c_str());
+        PyObject* pyresname = cpyrt_PyText_FromString(resname.c_str());
         if (!bExactMatch) {
             exact = PyObject_GetItem(dct, pyresname);
             if (!exact) PyErr_Clear();
@@ -241,13 +241,13 @@ PyObject* TemplateProxy::Instantiate(const std::string& fname,
         bool bIsConstructor = false, bNeedsRebind = true;
 
         PyCallable* meth = nullptr;
-        if (Cppyy::IsNamespace(scope)) {
+        if (cppjit::interop::IsNamespace(scope)) {
             meth = new CPPFunction(scope, cppmeth);
             bNeedsRebind = false;
-        } else if (Cppyy::IsStaticMethod(cppmeth)) {
+        } else if (cppjit::interop::IsStaticMethod(cppmeth)) {
             meth = new CPPClassMethod(scope, cppmeth);
             bNeedsRebind = false;
-        } else if (Cppyy::IsConstructor(cppmeth)) {
+        } else if (cppjit::interop::IsConstructor(cppmeth)) {
             bIsConstructor = true;
             meth = new CPPConstructor(scope, cppmeth);
         } else
@@ -311,7 +311,7 @@ PyObject* TemplateProxy::Instantiate(const std::string& fname,
 }
 
 
-//= CPyCppyy template proxy construction/destruction =========================
+//= cpyrt template proxy construction/destruction =========================
 static TemplateProxy* tpp_new(PyTypeObject*, PyObject*, PyObject*)
 {
 // Create a new empty template method proxy.
@@ -396,8 +396,8 @@ static PyObject* tpp_doc(TemplateProxy* pytmpl, void*)
     if (pytmpl->fTI->fTemplated->HasMethods()) {
         PyObject* doc2 = PyObject_GetAttrString((PyObject*)pytmpl->fTI->fTemplated, "__doc__");
         if (doc && doc2) {
-            CPyCppyy_PyText_AppendAndDel(&doc, CPyCppyy_PyText_FromString("\n"));
-            CPyCppyy_PyText_AppendAndDel(&doc, doc2);
+            cpyrt_PyText_AppendAndDel(&doc, cpyrt_PyText_FromString("\n"));
+            cpyrt_PyText_AppendAndDel(&doc, doc2);
         } else if (!doc && doc2) {
             doc = doc2;
         }
@@ -405,8 +405,8 @@ static PyObject* tpp_doc(TemplateProxy* pytmpl, void*)
     if (pytmpl->fTI->fLowPriority->HasMethods()) {
         PyObject* doc2 = PyObject_GetAttrString((PyObject*)pytmpl->fTI->fLowPriority, "__doc__");
         if (doc && doc2) {
-            CPyCppyy_PyText_AppendAndDel(&doc, CPyCppyy_PyText_FromString("\n"));
-            CPyCppyy_PyText_AppendAndDel(&doc, doc2);
+            cpyrt_PyText_AppendAndDel(&doc, cpyrt_PyText_FromString("\n"));
+            cpyrt_PyText_AppendAndDel(&doc, doc2);
         } else if (!doc && doc2) {
             doc = doc2;
         }
@@ -415,7 +415,7 @@ static PyObject* tpp_doc(TemplateProxy* pytmpl, void*)
     if (doc)
         return doc;
 
-    return CPyCppyy_PyText_FromString(TemplateProxy_Type.tp_doc);
+    return cpyrt_PyText_FromString(TemplateProxy_Type.tp_doc);
 }
 
 static int tpp_doc_set(TemplateProxy* pytmpl, PyObject *val, void *)
@@ -428,7 +428,7 @@ static int tpp_doc_set(TemplateProxy* pytmpl, PyObject *val, void *)
 
 //----------------------------------------------------------------------------
 
-//= CPyCppyy template proxy callable behavior ================================
+//= cpyrt template proxy callable behavior ================================
 
 #define TPPCALL_RETURN                                                       \
 { errors.clear();                                                            \
@@ -453,7 +453,7 @@ static inline void UpdateDispatchMap(TemplateProxy* pytmpl, bool use_targs, uint
 }
 
 static inline PyObject* SelectAndForward(TemplateProxy* pytmpl, CPPOverload* pymeth,
-    CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds,
+    cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds,
     bool implicitOkay, bool use_targs, uint64_t sighash, std::vector<Utility::PyError_t>& errors)
 {
 // Forward a call to known overloads, if any.
@@ -465,7 +465,7 @@ static inline PyObject* SelectAndForward(TemplateProxy* pytmpl, CPPOverload* pym
             ((CPPOverload*)pycall)->fFlags |= CallContext::kNoImplicit;
 
     // now call the method with the arguments (loops internally)
-        PyObject* result = CPyCppyy_tp_call(pycall, args, nargsf, kwds);
+        PyObject* result = cpyrt_tp_call(pycall, args, nargsf, kwds);
         Py_DECREF(pycall);
         if (result) {
             UpdateDispatchMap(pytmpl, use_targs, sighash, pymeth);
@@ -478,7 +478,7 @@ static inline PyObject* SelectAndForward(TemplateProxy* pytmpl, CPPOverload* pym
 }
 
 static inline PyObject* CallMethodImp(TemplateProxy* pytmpl, PyObject*& pymeth,
-    CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds, bool impOK, uint64_t sighash)
+    cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds, bool impOK, uint64_t sighash)
 {
 // Actual call of a given overload: takes care of handlign of "self" and
 // dereferences the overloaded method after use.
@@ -491,11 +491,11 @@ static inline PyObject* CallMethodImp(TemplateProxy* pytmpl, PyObject*& pymeth,
     // this is a global method added a posteriori to the class
         PyCallArgs cargs{(CPPInstance*&)pytmpl->fSelf, args, nargsf, kwds};
         AdjustSelf(cargs);
-        result = CPyCppyy_tp_call(pymeth, cargs.fArgs, cargs.fNArgsf, cargs.fKwds);
+        result = cpyrt_tp_call(pymeth, cargs.fArgs, cargs.fNArgsf, cargs.fKwds);
     } else {
         if (!pytmpl->fSelf && CPPOverload_Check(pymeth))
             ((CPPOverload*)pymeth)->fFlags &= ~CallContext::kFromDescr;
-        result = CPyCppyy_tp_call(pymeth, args, nargsf, kwds);
+        result = cpyrt_tp_call(pymeth, args, nargsf, kwds);
     }
 
     if (result) {
@@ -541,7 +541,7 @@ static PyObject* tpp_vectorcall(
     PyObject *pymeth = nullptr, *result = nullptr;
 
 // short-cut through memoization map
-    Py_ssize_t argc = CPyCppyy_PyArgs_GET_SIZE(args, nargsf);
+    Py_ssize_t argc = cpyrt_PyArgs_GET_SIZE(args, nargsf);
     uint64_t sighash = HashSignature(args, argc);
 
     CPPOverload* ol = nullptr;
@@ -557,11 +557,11 @@ static PyObject* tpp_vectorcall(
 
         if (ol != nullptr) {
             if (!pytmpl->fSelf || pytmpl->fSelf == Py_None) {
-                result = CPyCppyy_tp_call((PyObject*)ol, args, nargsf, kwds);
+                result = cpyrt_tp_call((PyObject*)ol, args, nargsf, kwds);
             } else {
                 pymeth = CPPOverload_Type.tp_descr_get(
                     (PyObject*)ol, pytmpl->fSelf, (PyObject*)&CPPOverload_Type);
-                result = CPyCppyy_tp_call(pymeth, args, nargsf, kwds);
+                result = cpyrt_tp_call(pymeth, args, nargsf, kwds);
                 Py_DECREF(pymeth); pymeth = nullptr;
             }
             if (result)
@@ -576,8 +576,8 @@ static PyObject* tpp_vectorcall(
 // case 1: explicit template previously selected through subscript
     if (pytmpl->fTemplateArgs) {
     // instantiate explicitly
-        PyObject* pyfullname = CPyCppyy_PyText_FromString(pytmpl->fTI->fCppName.c_str());
-        CPyCppyy_PyText_Append(&pyfullname, pytmpl->fTemplateArgs);
+        PyObject* pyfullname = cpyrt_PyText_FromString(pytmpl->fTI->fCppName.c_str());
+        cpyrt_PyText_Append(&pyfullname, pytmpl->fTemplateArgs);
 
     // first, lookup by full name, if previously stored
         bool isNS = (((CPPScope*)pytmpl->fTI->fPyClass)->fFlags & CPPScope::kIsNamespace);
@@ -597,7 +597,7 @@ static PyObject* tpp_vectorcall(
             Utility::FetchError(errors);
         } else if (pymeth && PyCallable_Check(pymeth)) {
         // something different (user provided?)
-            result = CPyCppyy_PyObject_Call(pymeth, args, nargsf, kwds);
+            result = cpyrt_PyObject_Call(pymeth, args, nargsf, kwds);
             Py_DECREF(pymeth);
             if (result) {
                 Py_DECREF(pyfullname);
@@ -609,7 +609,7 @@ static PyObject* tpp_vectorcall(
 
     // not cached or failed call; try instantiation
         pymeth = pytmpl->Instantiate(
-            CPyCppyy_PyText_AsString(pyfullname), args, nargsf, Utility::kNone);
+            cpyrt_PyText_AsString(pyfullname), args, nargsf, Utility::kNone);
         if (pymeth) {
         // attempt actual call; same as above, allow implicit conversion of arguments
             result = CallMethodImp(pytmpl, pymeth, args, nargsf, kwds, /*impOK=*/true, sighash);
@@ -621,8 +621,8 @@ static PyObject* tpp_vectorcall(
 
     // no drop through if failed (if implicit was desired, don't provide template args)
         Utility::FetchError(errors);
-        PyObject* topmsg = CPyCppyy_PyText_FromFormat(
-            "Could not find \"%s\" (set cppyy.set_debug() for C++ errors):", CPyCppyy_PyText_AsString(pyfullname));
+        PyObject* topmsg = cpyrt_PyText_FromFormat(
+            "Could not find \"%s\" (set cppjit.set_debug() for C++ errors):", cpyrt_PyText_AsString(pyfullname));
         Py_DECREF(pyfullname);
         Utility::SetDetailedException(std::move(errors), topmsg /* steals */, PyExc_TypeError /* default error */);
 
@@ -664,7 +664,7 @@ static PyObject* tpp_vectorcall(
 
 // error reporting is fraud, given the numerous steps taken, but more details seems better
     if (!errors.empty()) {
-        PyObject* topmsg = CPyCppyy_PyText_FromString("Template method resolution failed:");
+        PyObject* topmsg = cpyrt_PyText_FromString("Template method resolution failed:");
         Utility::SetDetailedException(std::move(errors), topmsg /* steals */, PyExc_TypeError /* default error */);
     } else {
         PyErr_Format(PyExc_TypeError, "cannot resolve method template call for \'%s\'",
@@ -709,7 +709,7 @@ static PyObject* tpp_subscript(TemplateProxy* pytmpl, PyObject* args)
 // to template specializations.
     TemplateProxy* typeBoundMethod = tpp_descr_get(pytmpl, pytmpl->fSelf, nullptr);
     Py_XDECREF(typeBoundMethod->fTemplateArgs);
-    typeBoundMethod->fTemplateArgs = CPyCppyy_PyText_FromString(
+    typeBoundMethod->fTemplateArgs = cpyrt_PyText_FromString(
         Utility::ConstructTemplateArgs(nullptr, args).c_str());
 // Propagate the error that occurs if we can't construct the C++ name
 // from the provided template argument
@@ -765,7 +765,7 @@ void TemplateProxy::Set(const std::string& cppname, const std::string& pyname, P
 }
 
 
-//= CPyCppyy method proxy access to internals ================================
+//= cpyrt method proxy access to internals ================================
 static PyObject* tpp_overload(TemplateProxy* pytmpl, PyObject* args)
 {
 // Select and call a specific C++ overload, based on its signature.
@@ -773,8 +773,8 @@ static PyObject* tpp_overload(TemplateProxy* pytmpl, PyObject* args)
     PyObject* sigarg_tuple = nullptr;
     int want_const = -1;
 
-    Cppyy::TCppScope_t scope = nullptr;
-    Cppyy::TCppMethod_t cppmeth = nullptr;
+    cppjit::interop::TCppScope_t scope = nullptr;
+    cppjit::interop::TCppMethod_t cppmeth = nullptr;
     std::string proto;
 
     if (PyArg_ParseTuple(args, const_cast<char*>("s|i:__overload__"), &sigarg, &want_const)) {
@@ -798,7 +798,7 @@ static PyObject* tpp_overload(TemplateProxy* pytmpl, PyObject* args)
         }
 
         scope = ((CPPClass*)pytmpl->fTI->fPyClass)->fCppType;
-        cppmeth = Cppyy::GetMethodTemplate(
+        cppmeth = cppjit::interop::GetMethodTemplate(
             scope, pytmpl->fTI->fCppName, proto.substr(1, proto.size()-2));
     } else if (PyArg_ParseTuple(args, const_cast<char*>("O|i:__overload__"), &sigarg_tuple, &want_const)) {
         PyErr_Clear();
@@ -819,18 +819,18 @@ static PyObject* tpp_overload(TemplateProxy* pytmpl, PyObject* args)
         Py_ssize_t n = PyTuple_Size(sigarg_tuple);
         for (int i = 0; i < n; i++) {
             PyObject *pItem = PyTuple_GetItem(sigarg_tuple, i);
-            if(!CPyCppyy_PyText_Check(pItem)) {
+            if(!cpyrt_PyText_Check(pItem)) {
                 PyErr_Format(PyExc_LookupError, "argument types should be in string format");
                 return (PyObject*) nullptr;
             }
-            proto.append(CPyCppyy_PyText_AsString(pItem));
+            proto.append(cpyrt_PyText_AsString(pItem));
             if (i < n - 1)
                 proto.push_back(',');
         }
         proto.push_back('>');
 
         scope = ((CPPClass*)pytmpl->fTI->fPyClass)->fCppType;
-        cppmeth = Cppyy::GetMethodTemplate(
+        cppmeth = cppjit::interop::GetMethodTemplate(
             scope, pytmpl->fTI->fCppName, proto.substr(1, proto.size()-2));
     } else {
         PyErr_Format(PyExc_TypeError, "Unexpected arguments to __overload__");
@@ -846,11 +846,11 @@ static PyObject* tpp_overload(TemplateProxy* pytmpl, PyObject* args)
 
     // TODO: the next step should be consolidated with Instantiate()
     PyCallable* meth = nullptr;
-    if (Cppyy::IsNamespace(scope)) {
+    if (cppjit::interop::IsNamespace(scope)) {
         meth = new CPPFunction(scope, cppmeth);
-    } else if (Cppyy::IsStaticMethod(cppmeth)) {
+    } else if (cppjit::interop::IsStaticMethod(cppmeth)) {
         meth = new CPPClassMethod(scope, cppmeth);
-    } else if (Cppyy::IsConstructor(cppmeth)) {
+    } else if (cppjit::interop::IsConstructor(cppmeth)) {
        meth = new CPPConstructor(scope, cppmeth);
     } else
         meth = new CPPMethod(scope, cppmeth);
@@ -865,10 +865,10 @@ static PyMethodDef tpp_methods[] = {
 };
 
 
-//= CPyCppyy template proxy type =============================================
+//= cpyrt template proxy type =============================================
 PyTypeObject TemplateProxy_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.TemplateProxy",      // tp_name
+    (char*)"cppjit.TemplateProxy",      // tp_name
     sizeof(TemplateProxy),             // tp_basicsize
     0,                                 // tp_itemsize
     (destructor)tpp_dealloc,           // tp_dealloc
@@ -888,7 +888,7 @@ PyTypeObject TemplateProxy_Type = {
     0,                                 // tp_as_buffer
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC
         | Py_TPFLAGS_HAVE_VECTORCALL | Py_TPFLAGS_METHOD_DESCRIPTOR, // tp_flags
-    (char*)"cppyy template proxy (internal)",     // tp_doc
+    (char*)"cppjit template proxy (internal)",     // tp_doc
     (traverseproc)tpp_traverse,        // tp_traverse
     (inquiry)tpp_clear,                // tp_clear
     (richcmpfunc)tpp_richcompare,      // tp_richcompare
@@ -917,7 +917,7 @@ PyTypeObject TemplateProxy_Type = {
     0,                                 // tp_version_tag
     0,                                 // tp_finalize
     0                                  // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
diff --git a/src/CPyCppyy/src/TemplateProxy.h b/src/cpyrt/TemplateProxy.h
similarity index 91%
rename from src/CPyCppyy/src/TemplateProxy.h
rename to src/cpyrt/TemplateProxy.h
index 79c7402..475ffa5 100644
--- a/src/CPyCppyy/src/TemplateProxy.h
+++ b/src/cpyrt/TemplateProxy.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_TEMPLATEPROXY_H
-#define CPYCPPYY_TEMPLATEPROXY_H
+#ifndef CPYRT_TEMPLATEPROXY_H
+#define CPYRT_TEMPLATEPROXY_H
 
 // Bindings
 #include "CPPScope.h"
@@ -13,7 +13,7 @@
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class PyCallable;
 class CPPOverload;
@@ -63,7 +63,7 @@ class TemplateProxy {
     void AdoptMethod(PyCallable* pc);
     void AdoptTemplate(PyCallable* pc);
     PyObject* Instantiate(const std::string& fname,
-        CPyCppyy_PyArgs_t tmplArgs, size_t nargsf, Utility::ArgPreference, int* pcnt = nullptr);
+        cpyrt_PyArgs_t tmplArgs, size_t nargsf, Utility::ArgPreference, int* pcnt = nullptr);
 
 private:                // private, as the python C-API will handle creation
     TemplateProxy() = delete;
@@ -98,6 +98,6 @@ inline TemplateProxy* TemplateProxy_New(
     return pytmpl;
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_TEMPLATEPROXY_H
+#endif // !CPYRT_TEMPLATEPROXY_H
diff --git a/src/CPyCppyy/src/TupleOfInstances.cxx b/src/cpyrt/TupleOfInstances.cxx
similarity index 91%
rename from src/CPyCppyy/src/TupleOfInstances.cxx
rename to src/cpyrt/TupleOfInstances.cxx
index e7308ab..4342e87 100644
--- a/src/CPyCppyy/src/TupleOfInstances.cxx
+++ b/src/cpyrt/TupleOfInstances.cxx
@@ -1,8 +1,8 @@
 #include "Python.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "TupleOfInstances.h"
 #include "ProxyWrappers.h"
 
@@ -11,7 +11,7 @@ namespace {
 
 typedef struct {
     PyObject_HEAD
-    Cppyy::TCppScope_t        ia_klass;
+    cppjit::interop::TCppScope_t        ia_klass;
     void*                    ia_array_start;
     Py_ssize_t               ia_pos;
     Py_ssize_t               ia_len;
@@ -26,7 +26,7 @@ static PyObject* ia_iternext(ia_iterobject* ia) {
         PyErr_SetString(PyExc_ReferenceError, "no stride available for indexing");
         return nullptr;
     }
-    PyObject* result = CPyCppyy::BindCppObjectNoCast(
+    PyObject* result = cppjit::cpyrt::BindCppObjectNoCast(
         (char*)ia->ia_array_start + ia->ia_pos*ia->ia_stride, ia->ia_klass);
     ia->ia_pos += 1;
     return result;
@@ -74,7 +74,7 @@ static PyObject* ia_subscript(ia_iterobject* ia, PyObject* pyidx)
         return nullptr;
     }
 
-    return CPyCppyy::BindCppObjectNoCast(
+    return cppjit::cpyrt::BindCppObjectNoCast(
         (char*)ia->ia_array_start + ia->ia_pos*ia->ia_stride, ia->ia_klass);
 }
 
@@ -87,11 +87,11 @@ static PyMappingMethods ia_as_mapping = {
 } // unnamed namespace
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 PyTypeObject InstanceArrayIter_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.instancearrayiter",  // tp_name
+    (char*)"cppjit.instancearrayiter",  // tp_name
     sizeof(ia_iterobject),        // tp_basicsize
     0,
     (destructor)PyObject_GC_Del,  // tp_dealloc
@@ -112,13 +112,13 @@ PyTypeObject InstanceArrayIter_Type = {
     0,                            // tp_version_tag
     0,                            // tp_finalize
     0                             // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
 
 //= support for C-style arrays of objects ====================================
 PyObject* TupleOfInstances_New(
-    Cppyy::TCppObject_t address, Cppyy::TCppScope_t klass, cdims_t dims)
+    cppjit::interop::TCppObject_t address, cppjit::interop::TCppScope_t klass, cdims_t dims)
 {
 // recursively set up tuples of instances on all dimensions
     if (dims.ndim() == UNKNOWN_SIZE || dims[0] == UNKNOWN_SIZE /* unknown shape or size */) {
@@ -130,7 +130,7 @@ PyObject* TupleOfInstances_New(
         ia->ia_array_start = address.data;
         ia->ia_pos         = 0;
         ia->ia_len         = -1;
-        ia->ia_stride      = Cppyy::SizeOf(klass);
+        ia->ia_stride      = cppjit::interop::SizeOf(klass);
 
         PyObject_GC_Track(ia);
         return (PyObject*)ia;
@@ -141,7 +141,7 @@ PyObject* TupleOfInstances_New(
             if (dims[i] != 0)
                 block_size *= (size_t)dims[i];
         }
-        block_size *= Cppyy::SizeOf(klass);
+        block_size *= cppjit::interop::SizeOf(klass);
 
         Py_ssize_t nelems = dims[0];
         PyObject* tup = PyTuple_New(nelems);
@@ -153,11 +153,11 @@ PyObject* TupleOfInstances_New(
     } else {
     // innermost dimension: construct tuple
         int nelems = (int)dims[0];
-        size_t block_size = Cppyy::SizeOf(klass);
+        size_t block_size = cppjit::interop::SizeOf(klass);
         if (block_size == 0) {
             PyErr_Format(PyExc_TypeError,
                 "can not determine size of type \"%s\" for array indexing",
-                Cppyy::GetScopedFinalName(klass).c_str());
+                cppjit::interop::GetScopedFinalName(klass).c_str());
             return nullptr;
         }
 
@@ -187,10 +187,10 @@ PyObject* TupleOfInstances_New(
     return nullptr;
 }
 
-//= CPyCppyy custom tuple-like array type ====================================
+//= cpyrt custom tuple-like array type ====================================
 PyTypeObject TupleOfInstances_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
-    (char*)"cppyy.InstancesArray", // tp_name
+    (char*)"cppjit.InstancesArray", // tp_name
     0,                             // tp_basicsize
     0,                             // tp_itemsize
     0,                             // tp_dealloc
@@ -239,7 +239,7 @@ PyTypeObject TupleOfInstances_Type = {
     0,                             // tp_version_tag
     0,                             // tp_finalize
     0                              // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
diff --git a/src/CPyCppyy/src/TupleOfInstances.h b/src/cpyrt/TupleOfInstances.h
similarity index 72%
rename from src/CPyCppyy/src/TupleOfInstances.h
rename to src/cpyrt/TupleOfInstances.h
index d903872..c83e573 100644
--- a/src/CPyCppyy/src/TupleOfInstances.h
+++ b/src/cpyrt/TupleOfInstances.h
@@ -1,11 +1,11 @@
-#ifndef CPYCPPYY_TUPLEOFINSTANCES_H
-#define CPYCPPYY_TUPLEOFINSTANCES_H
+#ifndef CPYRT_TUPLEOFINSTANCES_H
+#define CPYRT_TUPLEOFINSTANCES_H
 
 // Bindings
 #include "Dimensions.h"
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 /** Representation of C-style array of instances
       @author  WLAV
@@ -30,8 +30,8 @@ inline bool TupleOfInstances_CheckExact(T* object)
 }
 
 PyObject* TupleOfInstances_New(
-    Cppyy::TCppObject_t address, Cppyy::TCppScope_t klass, cdims_t dims);
+    cppjit::interop::TCppObject_t address, cppjit::interop::TCppScope_t klass, cdims_t dims);
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_TUPLEOFINSTANCES_H
+#endif // !CPYRT_TUPLEOFINSTANCES_H
diff --git a/src/CPyCppyy/src/TypeManip.cxx b/src/cpyrt/TypeManip.cxx
similarity index 92%
rename from src/CPyCppyy/src/TypeManip.cxx
rename to src/cpyrt/TypeManip.cxx
index bfead0b..919700d 100644
--- a/src/CPyCppyy/src/TypeManip.cxx
+++ b/src/cpyrt/TypeManip.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "TypeManip.h"
 
 // Standard
@@ -77,7 +77,7 @@ static inline void rstrip(std::string& name)
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::TypeManip::remove_const(const std::string& cppname)
+std::string cppjit::cpyrt::TypeManip::remove_const(const std::string& cppname)
 {
 // Remove 'const' qualifiers from the given C++ name.
     std::string::size_type tmplt_start = cppname.find('<');
@@ -103,7 +103,7 @@ std::string CPyCppyy::TypeManip::remove_const(const std::string& cppname)
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::TypeManip::clean_type(
+std::string cppjit::cpyrt::TypeManip::clean_type(
     const std::string& cppname, bool template_strip, bool const_strip)
 {
 // Strip C++ name from all qualifiers and compounds.
@@ -129,7 +129,7 @@ std::string CPyCppyy::TypeManip::clean_type(
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::TypeManip::template_base(const std::string& cppname)
+std::string cppjit::cpyrt::TypeManip::template_base(const std::string& cppname)
 {
 // If this is a template, return the underlying template name w/o arguments
     if (cppname.empty() || cppname.back() != '>')
@@ -153,7 +153,7 @@ std::string CPyCppyy::TypeManip::template_base(const std::string& cppname)
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::TypeManip::compound(const std::string& name)
+std::string cppjit::cpyrt::TypeManip::compound(const std::string& name)
 {
 // FIXME: temporary fix for translation unit decl being passed in 
 // CreateExecutor from InitExecutor_ (run test10_object_identity), remove later
@@ -181,7 +181,7 @@ std::string CPyCppyy::TypeManip::compound(const std::string& name)
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::TypeManip::cppscope_to_pyscope(std::string& cppscope)
+void cppjit::cpyrt::TypeManip::cppscope_to_pyscope(std::string& cppscope)
 {
 // Change '::' in C++ scope into '.' as in a Python scope.
     std::string::size_type pos = 0;
@@ -192,7 +192,7 @@ void CPyCppyy::TypeManip::cppscope_to_pyscope(std::string& cppscope)
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::TypeManip::cppscope_to_legalname(std::string& cppscope)
+void cppjit::cpyrt::TypeManip::cppscope_to_legalname(std::string& cppscope)
 {
 // Change characters illegal in a variable name into '_' to form a legal name.
     for (char& c : cppscope) {
@@ -202,7 +202,7 @@ void CPyCppyy::TypeManip::cppscope_to_legalname(std::string& cppscope)
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::TypeManip::extract_namespace(const std::string& name)
+std::string cppjit::cpyrt::TypeManip::extract_namespace(const std::string& name)
 {
 // Find the namespace the named class lives in, take care of templates
     if (name.empty())
@@ -230,7 +230,7 @@ std::string CPyCppyy::TypeManip::extract_namespace(const std::string& name)
 }
 
 //----------------------------------------------------------------------------
-std::vector<std::string> CPyCppyy::TypeManip::extract_arg_types(const std::string& sig)
+std::vector<std::string> cppjit::cpyrt::TypeManip::extract_arg_types(const std::string& sig)
 {
 // break out the argument types from the signature string
     std::vector<std::string> result;
@@ -264,7 +264,7 @@ std::vector<std::string> CPyCppyy::TypeManip::extract_arg_types(const std::strin
 }
 
 //----------------------------------------------------------------------------
-Py_ssize_t CPyCppyy::TypeManip::array_size(const std::string& name)
+Py_ssize_t cppjit::cpyrt::TypeManip::array_size(const std::string& name)
 {
 // Extract the array size from a given type name (assumes 1D arrays)
     std::string cleanName = remove_const(name);
diff --git a/src/CPyCppyy/src/TypeManip.h b/src/cpyrt/TypeManip.h
similarity index 83%
rename from src/CPyCppyy/src/TypeManip.h
rename to src/cpyrt/TypeManip.h
index 4fb8bd0..a810935 100644
--- a/src/CPyCppyy/src/TypeManip.h
+++ b/src/cpyrt/TypeManip.h
@@ -1,11 +1,11 @@
-#ifndef CPYCPPYY_TYPEMANIP_H
-#define CPYCPPYY_TYPEMANIP_H
+#ifndef CPYRT_TYPEMANIP_H
+#define CPYRT_TYPEMANIP_H
 
 #include <string>
 #include <vector>
 
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 namespace TypeManip {
 
@@ -24,6 +24,6 @@ namespace TypeManip {
 
 } // namespace TypeManip
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_TYPEMANIP_H
+#endif // !CPYRT_TYPEMANIP_H
diff --git a/src/CPyCppyy/src/Utility.cxx b/src/cpyrt/Utility.cxx
similarity index 82%
rename from src/CPyCppyy/src/Utility.cxx
rename to src/cpyrt/Utility.cxx
index bbe9d16..0864c8a 100644
--- a/src/CPyCppyy/src/Utility.cxx
+++ b/src/cpyrt/Utility.cxx
@@ -1,10 +1,10 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "Utility.h"
 #include "CPPFunction.h"
 #include "CPPInstance.h"
 #include "CPPOverload.h"
-#include "CPyCppyy/DispatchPtr.h"
+#include "cpyrt/DispatchPtr.h"
 #include "ProxyWrappers.h"
 #include "PyCallable.h"
 #include "PyStrings.h"
@@ -25,7 +25,7 @@
 
 //- data _____________________________________________________________________
 #if PY_VERSION_HEX < 0x030b0000
-bool CPyCppyy::gDictLookupActive = false;
+bool cppjit::cpyrt::gDictLookupActive = false;
 #endif
 
 typedef std::unordered_map<std::string, std::string> TC2POperatorMapping_t;
@@ -33,7 +33,7 @@ static TC2POperatorMapping_t gC2POperatorMapping;
 static std::set<std::string> gOpSkip;
 static std::set<std::string> gOpRemove;
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 // special objects
     extern PyObject* gNullPtrObject;
     extern PyObject* gDefaultObject;
@@ -41,7 +41,7 @@ namespace CPyCppyy {
 
 namespace {
 
-    using namespace CPyCppyy::Utility;
+    using namespace cppjit::cpyrt::Utility;
 
     struct InitOperatorMapping_t {
     public:
@@ -76,7 +76,7 @@ namespace {
             gC2POperatorMapping["+="]  = "__iadd__";
             gC2POperatorMapping["-="]  = "__isub__";
             gC2POperatorMapping["*="]  = "__imul__";
-            gC2POperatorMapping["/="]  = CPPYY__idiv__;
+            gC2POperatorMapping["/="]  = CPPJIT__idiv__;
             gC2POperatorMapping["%="]  = "__imod__";
             gC2POperatorMapping["**="] = "__ipow__";
             gC2POperatorMapping["<<="] = "__ilshift__";
@@ -97,7 +97,7 @@ namespace {
             gC2POperatorMapping["const char *"] = gC2POperatorMapping["const char*"];
             gC2POperatorMapping["char *"]       = gC2POperatorMapping["char*"];
             gC2POperatorMapping["int"]          = "__int__";
-            gC2POperatorMapping["long"]         = CPPYY__long__;
+            gC2POperatorMapping["long"]         = CPPJIT__long__;
             gC2POperatorMapping["double"]       = "__float__";
 
         // the following type mappings are "okay"; the assumption is that they
@@ -105,10 +105,10 @@ namespace {
         // they are, that it is done consistently)
             gC2POperatorMapping["short"]              = "__int__";
             gC2POperatorMapping["unsigned short"]     = "__int__";
-            gC2POperatorMapping["unsigned int"]       = CPPYY__long__;
-            gC2POperatorMapping["unsigned long"]      = CPPYY__long__;
-            gC2POperatorMapping["long long"]          = CPPYY__long__;
-            gC2POperatorMapping["unsigned long long"] = CPPYY__long__;
+            gC2POperatorMapping["unsigned int"]       = CPPJIT__long__;
+            gC2POperatorMapping["unsigned long"]      = CPPJIT__long__;
+            gC2POperatorMapping["long long"]          = CPPJIT__long__;
+            gC2POperatorMapping["unsigned long long"] = CPPJIT__long__;
             gC2POperatorMapping["float"]              = "__float__";
 
             gC2POperatorMapping["->"]  = "__follow__";      // not an actual python operator
@@ -126,13 +126,13 @@ namespace {
 
 
 //- public functions ---------------------------------------------------------
-unsigned long CPyCppyy::PyLongOrInt_AsULong(PyObject* pyobject)
+unsigned long cppjit::cpyrt::PyLongOrInt_AsULong(PyObject* pyobject)
 {
 // Convert <pybject> to C++ unsigned long, with bounds checking, allow int -> ulong.
     if (PyFloat_Check(pyobject)) {
         PyErr_SetString(PyExc_TypeError, "can\'t convert float to unsigned long");
         return (unsigned long)-1;
-    } else if (pyobject == CPyCppyy::gDefaultObject) {
+    } else if (pyobject == cppjit::cpyrt::gDefaultObject) {
         return (unsigned long)0;
     }
 
@@ -153,13 +153,13 @@ unsigned long CPyCppyy::PyLongOrInt_AsULong(PyObject* pyobject)
 }
 
 //----------------------------------------------------------------------------
-PY_ULONG_LONG CPyCppyy::PyLongOrInt_AsULong64(PyObject* pyobject)
+PY_ULONG_LONG cppjit::cpyrt::PyLongOrInt_AsULong64(PyObject* pyobject)
 {
 // Convert <pyobject> to C++ unsigned long long, with bounds checking.
     if (PyFloat_Check(pyobject)) {
         PyErr_SetString(PyExc_TypeError, "can\'t convert float to unsigned long long");
         return -1;
-    } else if (pyobject == CPyCppyy::gDefaultObject) {
+    } else if (pyobject == cppjit::cpyrt::gDefaultObject) {
         return (unsigned long)0;
     }
 
@@ -179,7 +179,7 @@ PY_ULONG_LONG CPyCppyy::PyLongOrInt_AsULong64(PyObject* pyobject)
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::Utility::AddToClass(
+bool cppjit::cpyrt::Utility::AddToClass(
     PyObject* pyclass, const char* label, PyCFunction cfunc, int flags)
 {
 // Add the given function to the class under name 'label'.
@@ -195,7 +195,7 @@ bool CPyCppyy::Utility::AddToClass(
     pdef->ml_doc   = nullptr;
 
     PyObject* func = PyCFunction_New(pdef, nullptr);
-    PyObject* name = CPyCppyy_PyText_InternFromString(pdef->ml_name);
+    PyObject* name = cpyrt_PyText_InternFromString(pdef->ml_name);
     PyObject* method = CustomInstanceMethod_New(func, nullptr, pyclass);
     PyObject* pytype = 0, *pyvalue = 0, *pytrace = 0;
     PyErr_Fetch(&pytype, &pyvalue, &pytrace);
@@ -217,14 +217,14 @@ bool CPyCppyy::Utility::AddToClass(
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::Utility::AddToClass(PyObject* pyclass, const char* label, const char* func)
+bool cppjit::cpyrt::Utility::AddToClass(PyObject* pyclass, const char* label, const char* func)
 {
 // Add the given function to the class under name 'label'.
     PyObject* pyfunc = PyObject_GetAttrString(pyclass, const_cast<char*>(func));
     if (!pyfunc)
         return false;
 
-    PyObject* pylabel = CPyCppyy_PyText_InternFromString(const_cast<char*>(label));
+    PyObject* pylabel = cpyrt_PyText_InternFromString(const_cast<char*>(label));
     bool isOk = PyType_Type.tp_setattro(pyclass, pylabel, pyfunc) == 0;
     Py_DECREF(pylabel);
 
@@ -233,7 +233,7 @@ bool CPyCppyy::Utility::AddToClass(PyObject* pyclass, const char* label, const c
 }
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::Utility::AddToClass(PyObject* pyclass, const char* label, PyCallable* pyfunc)
+bool cppjit::cpyrt::Utility::AddToClass(PyObject* pyclass, const char* label, PyCallable* pyfunc)
 {
 // Add the given function to the class under name 'label'.
     CPPOverload* method =
@@ -245,7 +245,7 @@ bool CPyCppyy::Utility::AddToClass(PyObject* pyclass, const char* label, PyCalla
             PyErr_Clear();
         Py_XDECREF((PyObject*)method);
         method = CPPOverload_New(label, pyfunc);
-        PyObject* pylabel = CPyCppyy_PyText_InternFromString(const_cast<char*>(label));
+        PyObject* pylabel = cpyrt_PyText_InternFromString(const_cast<char*>(label));
         bool isOk = PyType_Type.tp_setattro(pyclass, pylabel, (PyObject*)method) == 0;
         Py_DECREF(pylabel);
         Py_DECREF(method);
@@ -261,22 +261,22 @@ bool CPyCppyy::Utility::AddToClass(PyObject* pyclass, const char* label, PyCalla
 
 //----------------------------------------------------------------------------
 static inline
-CPyCppyy::PyCallable* BuildOperator(const std::string& lcname, const std::string& rcname,
-    const char* op, Cppyy::TCppScope_t scope, bool reverse=false)
+cppjit::cpyrt::PyCallable* BuildOperator(const std::string& lcname, const std::string& rcname,
+    const char* op, cppjit::interop::TCppScope_t scope, bool reverse=false)
 {
 // Helper to find a function with matching signature in 'funcs'.
 
-    Cppyy::TCppMethod_t meth = Cppyy::GetGlobalOperator(scope, lcname, rcname, op);
+    cppjit::interop::TCppMethod_t meth = cppjit::interop::GetGlobalOperator(scope, lcname, rcname, op);
     if (!meth)
         return nullptr;
 
     if (!reverse)
-        return new CPyCppyy::CPPFunction(scope, meth);
-    return new CPyCppyy::CPPReverseBinary(scope, meth);
+        return new cppjit::cpyrt::CPPFunction(scope, meth);
+    return new cppjit::cpyrt::CPPReverseBinary(scope, meth);
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::PyCallable* CPyCppyy::Utility::FindUnaryOperator(PyObject* pyclass, const char* op)
+cppjit::cpyrt::PyCallable* cppjit::cpyrt::Utility::FindUnaryOperator(PyObject* pyclass, const char* op)
 {
 // Find a callable matching named operator (op) and klass arguments in the global
 // namespace or the klass' namespace.
@@ -285,14 +285,14 @@ CPyCppyy::PyCallable* CPyCppyy::Utility::FindUnaryOperator(PyObject* pyclass, co
         return nullptr;
 
     CPPClass* klass = (CPPClass*)pyclass;
-    const std::string& lcname = Cppyy::GetScopedFinalName(klass->fCppType);
-    Cppyy::TCppScope_t scope = Cppyy::GetScope(TypeManip::extract_namespace(lcname));
+    const std::string& lcname = cppjit::interop::GetScopedFinalName(klass->fCppType);
+    cppjit::interop::TCppScope_t scope = cppjit::interop::GetScope(TypeManip::extract_namespace(lcname));
     return FindBinaryOperator(lcname, "", op, scope, false);
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::PyCallable* CPyCppyy::Utility::FindBinaryOperator(PyObject* left, PyObject* right,
-    const char* op, Cppyy::TCppScope_t scope)
+cppjit::cpyrt::PyCallable* cppjit::cpyrt::Utility::FindBinaryOperator(PyObject* left, PyObject* right,
+    const char* op, cppjit::interop::TCppScope_t scope)
 {
 // Find a callable matching the named operator (op) and the (left, right)
 // arguments in the global or these objects' namespaces.
@@ -312,12 +312,12 @@ CPyCppyy::PyCallable* CPyCppyy::Utility::FindBinaryOperator(PyObject* left, PyOb
 }
 
 //----------------------------------------------------------------------------
-CPyCppyy::PyCallable* CPyCppyy::Utility::FindBinaryOperator(
+cppjit::cpyrt::PyCallable* cppjit::cpyrt::Utility::FindBinaryOperator(
     const std::string& lcname, const std::string& rcname,
-    const char* op, Cppyy::TCppScope_t scope, bool reverse)
+    const char* op, cppjit::interop::TCppScope_t scope, bool reverse)
 {
 // Find a global function with a matching signature; search __gnu_cxx, std::__1,
-// and __cppyy_internal pro-actively (as there's AFAICS no way to unearth 'using'
+// and __cppjit_internal pro-actively (as there's AFAICS no way to unearth 'using'
 // information).
 
     if (rcname == "<unknown>" || lcname == "<unknown>")
@@ -329,23 +329,23 @@ CPyCppyy::PyCallable* CPyCppyy::Utility::FindBinaryOperator(
         // TODO: the following should remain sync with what clingwrapper does in its
         // type remapper; there must be a better way?
         if (lcname == "str" || lcname == "unicode" || lcname == "complex" || lcname.find("std::") == 0)
-            scope = Cppyy::GetScope("std");
+            scope = cppjit::interop::GetScope("std");
     }
     if (scope)
         pyfunc = BuildOperator(lcname, rcname, op, scope, reverse);
     if (!pyfunc)
-        if ((scope = Cppyy::GetScope(TypeManip::extract_namespace(lcname))))
+        if ((scope = cppjit::interop::GetScope(TypeManip::extract_namespace(lcname))))
             pyfunc = BuildOperator(lcname, rcname, op, scope, reverse);
 
-    if (!pyfunc && scope != Cppyy::GetGlobalScope())// search in global scope anyway
-        pyfunc = BuildOperator(lcname, rcname, op, Cppyy::GetGlobalScope(), reverse);
+    if (!pyfunc && scope != cppjit::interop::GetGlobalScope())// search in global scope anyway
+        pyfunc = BuildOperator(lcname, rcname, op, cppjit::interop::GetGlobalScope(), reverse);
 
     if (!pyfunc) {
     // For GNU on clang, search the internal __gnu_cxx namespace for binary operators (is
     // typically the case for STL iterators operator==/!=.
     // TODO: only look in __gnu_cxx for iterators (and more generally: do lookups in the
     //       namespace where the class is defined
-        static Cppyy::TCppScope_t gnucxx = Cppyy::GetScope("__gnu_cxx");
+        static cppjit::interop::TCppScope_t gnucxx = cppjit::interop::GetScope("__gnu_cxx");
         if (gnucxx)
             pyfunc = BuildOperator(lcname, rcname, op, gnucxx, reverse);
     }
@@ -353,7 +353,7 @@ CPyCppyy::PyCallable* CPyCppyy::Utility::FindBinaryOperator(
     if (!pyfunc) {
     // Same for clang (on Mac only?). TODO: find proper pre-processor magic to only use those
     // specific namespaces that are actually around; although to be sure, this isn't expensive.
-        static Cppyy::TCppScope_t std__1 = Cppyy::GetFullScope("std::__1");
+        static cppjit::interop::TCppScope_t std__1 = cppjit::interop::GetFullScope("std::__1");
 
         if (std__1
 #ifdef __APPLE__
@@ -368,7 +368,7 @@ CPyCppyy::PyCallable* CPyCppyy::Utility::FindBinaryOperator(
     // One more, mostly for Mac, but again not sure whether this is not a general issue. Some
     // operators are declared as friends only in classes, so then they're not found in the
     // global namespace, so this helper let's the compiler resolve the operator.
-        static Cppyy::TCppScope_t s_intern = Cppyy::GetScope("__cppyy_internal");
+        static cppjit::interop::TCppScope_t s_intern = cppjit::interop::GetScope("__cppjit_internal");
         if (s_intern) {
             std::stringstream fname, proto;
             if (strncmp(op, "==", 2) == 0) { fname << "is_equal<"; }
@@ -376,7 +376,7 @@ CPyCppyy::PyCallable* CPyCppyy::Utility::FindBinaryOperator(
             else { fname << "not_implemented<"; }
             fname << lcname << ", " << rcname << ">";
             proto << "const " << lcname << "&, const " << rcname;
-            Cppyy::TCppMethod_t method = Cppyy::GetMethodTemplate(s_intern, fname.str(), proto.str());
+            cppjit::interop::TCppMethod_t method = cppjit::interop::GetMethodTemplate(s_intern, fname.str(), proto.str());
             if (method) pyfunc = new CPPFunction(s_intern, method);
         }
     }
@@ -387,27 +387,27 @@ CPyCppyy::PyCallable* CPyCppyy::Utility::FindBinaryOperator(
 //----------------------------------------------------------------------------
 static inline std::string AnnotationAsText(PyObject* pyobj)
 {
-    if (!CPyCppyy_PyText_Check(pyobj)) {
-        PyObject* pystr = PyObject_GetAttr(pyobj, CPyCppyy::PyStrings::gName);
+    if (!cpyrt_PyText_Check(pyobj)) {
+        PyObject* pystr = PyObject_GetAttr(pyobj, cppjit::cpyrt::PyStrings::gName);
         if (!pystr) {
             PyErr_Clear();
             pystr = PyObject_Str(pyobj);
         }
 
-        std::string str = CPyCppyy_PyText_AsString(pystr);
+        std::string str = cpyrt_PyText_AsString(pystr);
         Py_DECREF(pystr);
         return str;
     }
-    return CPyCppyy_PyText_AsString(pyobj);
+    return cpyrt_PyText_AsString(pyobj);
 }
 
 static bool AddTypeName(std::string& tmpl_name, PyObject* tn, PyObject* arg,
-    CPyCppyy::Utility::ArgPreference pref, int* pcnt = nullptr)
+    cppjit::cpyrt::Utility::ArgPreference pref, int* pcnt = nullptr)
 {
 // Determine the appropriate C++ type for a given Python type; this is a helper because
 // it can recurse if the type is list or tuple and needs matching on std::vector.
-    using namespace CPyCppyy;
-    using namespace CPyCppyy::Utility;
+    using namespace cppjit::cpyrt;
+    using namespace cppjit::cpyrt::Utility;
 
     if (tn == (PyObject*)&PyInt_Type) {
         if (arg) {
@@ -462,7 +462,7 @@ static bool AddTypeName(std::string& tmpl_name, PyObject* tn, PyObject* arg,
     }
 
     if (CPPScope_Check(tn)) {
-        auto cpp_type = Cppyy::GetScopedFinalName(((CPPClass*)tn)->fCppType);
+        auto cpp_type = cppjit::interop::GetScopedFinalName(((CPPClass*)tn)->fCppType);
         tmpl_name.append(full_scope(cpp_type));
         if (arg) {
         // try to specialize the type match for the given object
@@ -486,8 +486,8 @@ static bool AddTypeName(std::string& tmpl_name, PyObject* tn, PyObject* arg,
     if (tn == (PyObject*)&CPPOverload_Type) {
         PyObject* tpName = arg ? \
             PyObject_GetAttr(arg, PyStrings::gCppName) : \
-            CPyCppyy_PyText_FromString("void* (*)(...)");
-        tmpl_name.append(CPyCppyy_PyText_AsString(tpName));
+            cpyrt_PyText_FromString("void* (*)(...)");
+        tmpl_name.append(cpyrt_PyText_AsString(tpName));
         Py_DECREF(tpName);
 
         return true;
@@ -563,7 +563,7 @@ static bool AddTypeName(std::string& tmpl_name, PyObject* tn, PyObject* arg,
     // callable C++ type (e.g. std::function)
         PyObject* tpName = PyObject_GetAttr(arg, PyStrings::gCppName);
         if (tpName) {
-            const char* cname = CPyCppyy_PyText_AsString(tpName);
+            const char* cname = cpyrt_PyText_AsString(tpName);
             tmpl_name.append(CPPScope_Check(arg) ? full_scope(cname) : cname);
             Py_DECREF(tpName);
             return true;
@@ -574,7 +574,7 @@ static bool AddTypeName(std::string& tmpl_name, PyObject* tn, PyObject* arg,
     for (auto nn : {PyStrings::gCppName, PyStrings::gName}) {
         PyObject* tpName = PyObject_GetAttr(tn, nn);
         if (tpName) {
-            tmpl_name.append(CPyCppyy_PyText_AsString(tpName));
+            tmpl_name.append(cpyrt_PyText_AsString(tpName));
             Py_DECREF(tpName);
             return true;
         }
@@ -586,7 +586,7 @@ static bool AddTypeName(std::string& tmpl_name, PyObject* tn, PyObject* arg,
     // source of errors otherwise, it is limited to specific types and not
     // generally used (str(obj) can print anything ...)
         PyObject* pystr = PyObject_Str(tn);
-        tmpl_name.append(CPyCppyy_PyText_AsString(pystr));
+        tmpl_name.append(cpyrt_PyText_AsString(pystr));
         Py_DECREF(pystr);
         return true;
     }
@@ -603,7 +603,7 @@ static bool AddTypeName(std::string& tmpl_name, PyObject* tn, PyObject* arg,
     return false;
 }
 
-std::string CPyCppyy::Utility::ConstructTemplateArgs(
+std::string cppjit::cpyrt::Utility::ConstructTemplateArgs(
     PyObject* pyname, PyObject* tpArgs, PyObject* args, ArgPreference pref, int argoff, int* pcnt)
 {
 // Helper to construct the "<type, type, ...>" part of a templated name (either
@@ -614,7 +614,7 @@ std::string CPyCppyy::Utility::ConstructTemplateArgs(
     std::string tmpl_name;
     tmpl_name.reserve(128);
     if (pyname)
-        tmpl_name.append(CPyCppyy_PyText_AsString(pyname));
+        tmpl_name.append(cpyrt_PyText_AsString(pyname));
     tmpl_name.push_back('<');
 
     if (pcnt) *pcnt = 0;     // count number of times 'pref' is used
@@ -623,8 +623,8 @@ std::string CPyCppyy::Utility::ConstructTemplateArgs(
     for (int i = argoff; i < nArgs; ++i) {
     // add type as string to name
         PyObject* tn = justOne ? tpArgs : PyTuple_GET_ITEM(tpArgs, i);
-        if (CPyCppyy_PyText_Check(tn)) {
-            tmpl_name.append(CPyCppyy_PyText_AsString(tn));
+        if (cpyrt_PyText_Check(tn)) {
+            tmpl_name.append(cpyrt_PyText_AsString(tn));
     // some common numeric types (separated out for performance: checking for
     // __cpp_name__ and/or __name__ is rather expensive)
         } else {
@@ -648,12 +648,12 @@ std::string CPyCppyy::Utility::ConstructTemplateArgs(
 
 //----------------------------------------------------------------------------
 static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn, 
-    PyObject* arg, CPyCppyy::Utility::ArgPreference pref, int* pcnt = nullptr)
+    PyObject* arg, cppjit::cpyrt::Utility::ArgPreference pref, int* pcnt = nullptr)
 {
 // Determine the appropriate C++ type for a given Python type; this is a helper because
 // it can recurse if the type is list or tuple and needs matching on std::vector.
-    using namespace CPyCppyy;
-    using namespace CPyCppyy::Utility;
+    using namespace cppjit::cpyrt;
+    using namespace cppjit::cpyrt::Utility;
 
     if (tn == (PyObject*)&PyInt_Type) {
         if (arg) {
@@ -663,14 +663,14 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
                  PY_ULONG_LONG ull = PyLong_AsUnsignedLongLong(arg);
                  if (ull == (PY_ULONG_LONG)-1 && PyErr_Occurred()) {
                      PyErr_Clear();
-                     types.push_back(Cppyy::GetType("int").data);    // still out of range, will fail later
+                     types.push_back(cppjit::interop::GetType("int").data);    // still out of range, will fail later
                  } else
-                     types.push_back(Cppyy::GetType("unsigned long long").data);    // since already failed long long
+                     types.push_back(cppjit::interop::GetType("unsigned long long").data);    // since already failed long long
              } else
-                 types.push_back(Cppyy::GetType((ll < INT_MIN || INT_MAX < ll) ? \
+                 types.push_back(cppjit::interop::GetType((ll < INT_MIN || INT_MAX < ll) ? \
                      ((ll < LONG_MIN || LONG_MAX < ll) ? "long long" : "long") : "int").data);
         } else {
-            types.push_back(Cppyy::GetType("int").data);
+            types.push_back(cppjit::interop::GetType("int").data);
         }
 
         return true;
@@ -678,12 +678,12 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
 
     if (tn == (PyObject*)&PyFloat_Type) {
     // special case for floats (Python-speak for double) if from argument (only)
-        types.push_back(Cppyy::GetType(arg ? "double" : "float").data);
+        types.push_back(cppjit::interop::GetType(arg ? "double" : "float").data);
         return true;
     }
 
     if (tn == (PyObject*)&PyUnicode_Type) {
-        types.push_back(Cppyy::GetType("std::string", /* enable_slow_lookup */ true).data);
+        types.push_back(cppjit::interop::GetType("std::string", /* enable_slow_lookup */ true).data);
         return true;
     }
 
@@ -694,7 +694,7 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
             ArgPreference subpref = pref == kValue ? kValue : kPointer;
             if (AddTypeName(subtype, (PyObject*)Py_TYPE(item), item, subpref)) {
                 subtype.append(">");
-                types.push_back(Cppyy::GetType(subtype).data);
+                types.push_back(cppjit::interop::GetType(subtype).data);
             }
             Py_DECREF(item);
         }
@@ -703,21 +703,21 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
     }
 
     if (CPPScope_Check(tn)) {
-      auto cpp_type = Cppyy::GetTypeFromScope(((CPPClass*)tn)->fCppType);
+      auto cpp_type = cppjit::interop::GetTypeFromScope(((CPPClass*)tn)->fCppType);
       if (arg) {
         // try to specialize the type match for the given object
             CPPInstance* pyobj = (CPPInstance*)arg;
             if (CPPInstance_Check(pyobj)) {
                 if (pyobj->fFlags & CPPInstance::kIsRValue)
                   cpp_type =
-                      Cppyy::GetReferencedType(cpp_type, /*rvalue=*/true);
+                      cppjit::interop::GetReferencedType(cpp_type, /*rvalue=*/true);
                 else {
                     if (pcnt) *pcnt += 1;
                     if ((pyobj->fFlags & CPPInstance::kIsReference) || pref == kPointer)
-                      cpp_type = Cppyy::GetPointerType(cpp_type);
+                      cpp_type = cppjit::interop::GetPointerType(cpp_type);
                     else if (pref != kValue)
                       cpp_type =
-                          Cppyy::GetReferencedType(cpp_type, /*rvalue=*/false);
+                          cppjit::interop::GetReferencedType(cpp_type, /*rvalue=*/false);
                 }
             }
       }
@@ -728,8 +728,8 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
     if (tn == (PyObject*)&CPPOverload_Type) {
         PyObject* tpName =  arg ? \
             PyObject_GetAttr(arg, PyStrings::gCppName) : \
-            CPyCppyy_PyText_FromString("void* (*)(...)");
-        types.push_back(Cppyy::GetType(CPyCppyy_PyText_AsString(tpName), /* enable_slow_lookup */ true).data);
+            cpyrt_PyText_FromString("void* (*)(...)");
+        types.push_back(cppjit::interop::GetType(cpyrt_PyText_AsString(tpName), /* enable_slow_lookup */ true).data);
         Py_DECREF(tpName);
 
         return true;
@@ -743,14 +743,14 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
                 if (ret) {
                 // dict is ordered, with the last value being the return type
                     std::ostringstream tpn;
-                    tpn << (CPPScope_Check(ret) ? ClassName(ret) : CPyCppyy_PyText_AsString(ret))
+                    tpn << (CPPScope_Check(ret) ? ClassName(ret) : cpyrt_PyText_AsString(ret))
                         << " (*)(";
 
                     PyObject* values = PyDict_Values(annot);
                     for (Py_ssize_t i = 0; i < (PyList_GET_SIZE(values)-1); ++i) {
                         if (i) tpn << ", ";
                         PyObject* item = PyList_GET_ITEM(values, i);
-                        tpn << (CPPScope_Check(item) ?  ClassName(item) : CPyCppyy_PyText_AsString(item));
+                        tpn << (CPPScope_Check(item) ?  ClassName(item) : cpyrt_PyText_AsString(item));
                     }
                     Py_DECREF(values);
 
@@ -771,7 +771,7 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
 
         PyObject* tpName = PyObject_GetAttr(arg, PyStrings::gCppName);
         if (tpName) {
-            types.push_back(Cppyy::GetType(CPyCppyy_PyText_AsString(tpName), /* enable_slow_lookup */ true).data);
+            types.push_back(cppjit::interop::GetType(cpyrt_PyText_AsString(tpName), /* enable_slow_lookup */ true).data);
             Py_DECREF(tpName);
             return true;
         }
@@ -781,15 +781,15 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
     for (auto nn : {PyStrings::gCppName, PyStrings::gName}) {
         PyObject* tpName = PyObject_GetAttr(tn, nn);
         if (tpName) {
-            Cppyy::TCppType_t type = Cppyy::GetType(CPyCppyy_PyText_AsString(tpName), /* enable_slow_lookup */ true);
-            if (Cppyy::IsEnumType(type)) {
+            cppjit::interop::TCppType_t type = cppjit::interop::GetType(cpyrt_PyText_AsString(tpName), /* enable_slow_lookup */ true);
+            if (cppjit::interop::IsEnumType(type)) {
                 PyObject *value_int = PyNumber_Index(tn);
                 if (!value_int) {
                     types.push_back(type.data);
                     PyErr_Clear();
                 } else {
                     PyObject* pystr = PyObject_Str(tn);
-                    std::string num = CPyCppyy_PyText_AsString(pystr);
+                    std::string num = cpyrt_PyText_AsString(pystr);
                     types.push_back({type.data, strdup(num.c_str())});
                     Py_DECREF(pystr);
                     Py_DECREF(value_int);
@@ -808,12 +808,12 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
     // source of errors otherwise, it is limited to specific types and not
     // generally used (str(obj) can print anything ...)
         PyObject* pystr = PyObject_Str(tn);
-        std::string num = CPyCppyy_PyText_AsString(pystr);
+        std::string num = cpyrt_PyText_AsString(pystr);
         if (num == "True")
             num = "1";
         else if (num == "False")
             num = "0";
-        types.push_back({Cppyy::GetType("int").data, strdup(num.c_str())});
+        types.push_back({cppjit::interop::GetType("int").data, strdup(num.c_str())});
         Py_DECREF(pystr);
         return true;
     }
@@ -821,7 +821,7 @@ static bool AddTypeName(std::vector<Cpp::TemplateArgInfo>& types, PyObject* tn,
     return false;
 }
 
-std::vector<Cpp::TemplateArgInfo> CPyCppyy::Utility::GetTemplateArgsTypes(
+std::vector<Cpp::TemplateArgInfo> cppjit::cpyrt::Utility::GetTemplateArgsTypes(
     PyObject* /*scope*/, PyObject* tpArgs, PyObject* args, ArgPreference pref, int argoff, int* pcnt)
 {
 // Helper to construct the "<type, type, ...>" part of a templated name (either
@@ -838,10 +838,10 @@ std::vector<Cpp::TemplateArgInfo> CPyCppyy::Utility::GetTemplateArgsTypes(
     for (int i = argoff; i < nArgs; ++i) {
     // add type as string to name
         PyObject* tn = justOne ? tpArgs : PyTuple_GET_ITEM(tpArgs, i);
-        if (CPyCppyy_PyText_Check(tn)) {
-            const char * tn_string = CPyCppyy_PyText_AsString(tn);
+        if (cpyrt_PyText_Check(tn)) {
+            const char * tn_string = cpyrt_PyText_AsString(tn);
 
-            if (Cppyy::AppendTypesSlow(tn_string, types)) {
+            if (cppjit::interop::AppendTypesSlow(tn_string, types)) {
                 PyErr_Format(PyExc_TypeError,
                              "Cannot find Templated Arg: %s", tn_string);
                 return {};
@@ -861,12 +861,12 @@ std::vector<Cpp::TemplateArgInfo> CPyCppyy::Utility::GetTemplateArgsTypes(
     return types;
 }
 
-std::string CPyCppyy::Utility::CT2CppNameS(PyObject* pytc, bool allow_voidp)
+std::string cppjit::cpyrt::Utility::CT2CppNameS(PyObject* pytc, bool allow_voidp)
 {
 // helper to convert ctypes' `_type_` info to the equivalent C++ name
     const char* name = "";
-    if (CPyCppyy_PyText_Check(pytc)) {
-        char tc = ((char*)CPyCppyy_PyText_AsString(pytc))[0];
+    if (cpyrt_PyText_Check(pytc)) {
+        char tc = ((char*)cpyrt_PyText_AsString(pytc))[0];
         switch (tc) {
             case '?': name = "bool";               break;
             case 'c': name = "char";               break;
@@ -894,10 +894,10 @@ std::string CPyCppyy::Utility::CT2CppNameS(PyObject* pytc, bool allow_voidp)
 //----------------------------------------------------------------------------
 static inline bool check_scope(const std::string& name)
 {
-    return (bool)Cppyy::GetScope(CPyCppyy::TypeManip::clean_type(name, false));
+    return (bool)cppjit::interop::GetScope(cppjit::cpyrt::TypeManip::clean_type(name, false));
 }
 
-void CPyCppyy::Utility::ConstructCallbackPreamble(const std::string& retType,
+void cppjit::cpyrt::Utility::ConstructCallbackPreamble(const std::string& retType,
     const std::vector<std::string>& argtypes, std::ostringstream& code)
 {
 // Generate function setup to be used in callbacks (wrappers and overrides).
@@ -906,20 +906,20 @@ void CPyCppyy::Utility::ConstructCallbackPreamble(const std::string& retType,
 // return value and argument type converters
     bool isVoid = retType.find("void") == 0; // might contain trailing space
     if (!isVoid)
-        code << "    CPYCPPYY_STATIC std::unique_ptr<CPyCppyy::Converter, std::function<void(CPyCppyy::Converter*)>> "
-                     "retconv{CPyCppyy::CreateConverter(\""
-             << retType << "\"), CPyCppyy::DestroyConverter};\n";
+        code << "    CPYRT_STATIC std::unique_ptr<cppjit::cpyrt::Converter, std::function<void(cppjit::cpyrt::Converter*)>> "
+                     "retconv{cppjit::cpyrt::CreateConverter(\""
+             << retType << "\"), cppjit::cpyrt::DestroyConverter};\n";
     std::vector<bool> arg_is_ptr;
     if (nArgs) {
         arg_is_ptr.resize(nArgs);
-        code << "    CPYCPPYY_STATIC std::vector<std::unique_ptr<CPyCppyy::Converter, std::function<void(CPyCppyy::Converter*)>>> argcvs;\n"
+        code << "    CPYRT_STATIC std::vector<std::unique_ptr<cppjit::cpyrt::Converter, std::function<void(cppjit::cpyrt::Converter*)>>> argcvs;\n"
              << "    if (argcvs.empty()) {\n"
              << "      argcvs.reserve(" << nArgs << ");\n";
         for (int i = 0; i < nArgs; ++i) {
             arg_is_ptr[i] = false;
-            code << "      argcvs.emplace_back(CPyCppyy::CreateConverter(\"";
+            code << "      argcvs.emplace_back(cppjit::cpyrt::CreateConverter(\"";
             const std::string& at = argtypes[i];
-            const std::string& res_at = Cppyy::ResolveName(at);
+            const std::string& res_at = cppjit::interop::ResolveName(at);
             const std::string& cpd = TypeManip::compound(res_at);
             if (!cpd.empty() && check_scope(res_at)) {
             // in case of a pointer, the original argument needs to be used to ensure
@@ -933,7 +933,7 @@ void CPyCppyy::Utility::ConstructCallbackPreamble(const std::string& retType,
                 } else code << at;
             } else
                  code << at;
-            code << "\"), CPyCppyy::DestroyConverter);\n";
+            code << "\"), cppjit::cpyrt::DestroyConverter);\n";
         }
         code << "    }\n";
     }
@@ -955,16 +955,16 @@ void CPyCppyy::Utility::ConstructCallbackPreamble(const std::string& retType,
         }
         code << "    } catch(int) {\n"
              << "      for (auto pyarg : pyargs) Py_XDECREF(pyarg);\n"
-             << "      CPyCppyy::PyException pyexc; throw pyexc;\n"
+             << "      cppjit::cpyrt::PyException pyexc; throw pyexc;\n"
              << "    }\n";
     }
 }
 
-void CPyCppyy::Utility::ConstructCallbackReturn(const std::string& retType, int nArgs, std::ostringstream& code)
+void cppjit::cpyrt::Utility::ConstructCallbackReturn(const std::string& retType, int nArgs, std::ostringstream& code)
 {
 // Generate code for return value conversion and error handling.
     bool isVoid = retType.find("void") == 0; // might contain trailing space
-    bool isPtr  = Cppyy::ResolveName(retType).back() == '*';
+    bool isPtr  = cppjit::interop::ResolveName(retType).back() == '*';
 
     if (nArgs)
         code << "    for (auto pyarg : pyargs) Py_DECREF(pyarg);\n";
@@ -973,7 +973,7 @@ void CPyCppyy::Utility::ConstructCallbackReturn(const std::string& retType, int
     if (isPtr) {
     // If the return type is a CPPInstance, owned by Python, and the ref-count down
     // to 1, the return will hold a dangling pointer, so set it to nullptr instead.
-        code << "      if (!CPyCppyy::Instance_IsLively(pyresult))\n"
+        code << "      if (!cppjit::cpyrt::Instance_IsLively(pyresult))\n"
                 "        ret = nullptr;\n"
                 "      else {\n";
     }
@@ -986,7 +986,7 @@ void CPyCppyy::Utility::ConstructCallbackReturn(const std::string& retType, int
 #ifdef _WIN32
             " /* do nothing */ }\n"
 #else
-            " CPyCppyy::PyException pyexc; throw pyexc; }\n"
+            " cppjit::cpyrt::PyException pyexc; throw pyexc; }\n"
 #endif
             "    return";
     code << (isVoid ? ";\n  }\n" : " ret;\n  }\n");
@@ -996,7 +996,7 @@ void CPyCppyy::Utility::ConstructCallbackReturn(const std::string& retType, int
 //----------------------------------------------------------------------------
 static std::unordered_map<void*, PyObject*> sStdFuncLookup;
 static std::unordered_map<std::string, PyObject*> sStdFuncMakerLookup;
-PyObject* CPyCppyy::Utility::FuncPtr2StdFunction(
+PyObject* cppjit::cpyrt::Utility::FuncPtr2StdFunction(
         const std::string& retType, const std::string& signature, void* address)
 {
 // Convert a function pointer to an equivalent std::function<> object.
@@ -1016,16 +1016,16 @@ PyObject* CPyCppyy::Utility::FuncPtr2StdFunction(
         fname << "ptr2func" << ++maker_count;
 
         std::ostringstream code;
-        code << "namespace __cppyy_internal { std::function<"
+        code << "namespace __cppjit_internal { std::function<"
              << retType << signature << "> " << fname.str()
              << "(intptr_t faddr) { return (" << retType << "(*)" << signature << ")faddr;} }";
 
-        if (!Cppyy::Compile(code.str())) {
+        if (!cppjit::interop::Compile(code.str())) {
             PyErr_SetString(PyExc_TypeError, "conversion to std::function failed");
             return nullptr;
         }
 
-        PyObject* pyscope = CreateScopeProxy("__cppyy_internal");
+        PyObject* pyscope = CreateScopeProxy("__cppjit_internal");
         maker = PyObject_GetAttrString(pyscope, fname.str().c_str());
         Py_DECREF(pyscope);
         if (!maker)
@@ -1052,7 +1052,7 @@ PyObject* CPyCppyy::Utility::FuncPtr2StdFunction(
 
 
 //----------------------------------------------------------------------------
-bool CPyCppyy::Utility::InitProxy(PyObject* module, PyTypeObject* pytype, const char* name)
+bool cppjit::cpyrt::Utility::InitProxy(PyObject* module, PyTypeObject* pytype, const char* name)
 {
 // Initialize a proxy class for use by python, and add it to the module.
 
@@ -1072,7 +1072,7 @@ bool CPyCppyy::Utility::InitProxy(PyObject* module, PyTypeObject* pytype, const
 }
 
 //----------------------------------------------------------------------------
-std::unordered_map<std::string, char> const &CPyCppyy::Utility::TypecodeMap()
+std::unordered_map<std::string, char> const &cppjit::cpyrt::Utility::TypecodeMap()
 {
    // See https://docs.python.org/3/library/array.html#array.array
    static std::unordered_map<std::string, char> typecodeMap{
@@ -1096,7 +1096,7 @@ std::unordered_map<std::string, char> const &CPyCppyy::Utility::TypecodeMap()
 }
 
 //----------------------------------------------------------------------------
-Py_ssize_t CPyCppyy::Utility::GetBuffer(PyObject* pyobject, char tc, int size, void*& buf, bool check)
+Py_ssize_t cppjit::cpyrt::Utility::GetBuffer(PyObject* pyobject, char tc, int size, void*& buf, bool check)
 {
 // Retrieve a linear buffer pointer from the given pyobject.
 
@@ -1181,7 +1181,7 @@ Py_ssize_t CPyCppyy::Utility::GetBuffer(PyObject* pyobject, char tc, int size, v
         // determine buffer compatibility (use "buf" as a status flag)
             PyObject* pytc = tc != '*' ? PyObject_GetAttr(pyobject, PyStrings::gTypeCode) : nullptr;
             if (pytc != 0) {      // for array objects
-                char cpytc = CPyCppyy_PyText_AsString(pytc)[0];
+                char cpytc = cpyrt_PyText_AsString(pytc)[0];
                 if (!(cpytc == tc || (tc == '?' && cpytc == 'b')))
                     buf = 0;      // no match
                 Py_DECREF(pytc);
@@ -1197,9 +1197,9 @@ Py_ssize_t CPyCppyy::Utility::GetBuffer(PyObject* pyobject, char tc, int size, v
 
             // clarify error message
                 auto error = FetchPyError();
-                PyObject* pyvalue2 = CPyCppyy_PyText_FromFormat(
+                PyObject* pyvalue2 = cpyrt_PyText_FromFormat(
                     (char*)"%s and given element size (%ld) do not match needed (%d)",
-                    CPyCppyy_PyText_AsString(error.fValue.get()),
+                    cpyrt_PyText_AsString(error.fValue.get()),
                     seqmeths->sq_length ? (long)(buflen/(*(seqmeths->sq_length))(pyobject)) : (long)buflen,
                     size);
                 error.fValue.reset(pyvalue2);
@@ -1215,7 +1215,7 @@ Py_ssize_t CPyCppyy::Utility::GetBuffer(PyObject* pyobject, char tc, int size, v
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::Utility::MapOperatorName(const std::string& name, bool bTakesParams, bool* stubbed)
+std::string cppjit::cpyrt::Utility::MapOperatorName(const std::string& name, bool bTakesParams, bool* stubbed)
 {
 // Map the given C++ operator name on the python equivalent.
     if (8 < name.size() && name.substr(0, 8) == "operator") {
@@ -1244,7 +1244,7 @@ std::string CPyCppyy::Utility::MapOperatorName(const std::string& name, bool bTa
 
         } else if (op == "/") {
         // no unary, but is stubbed
-            return CPPYY__div__;
+            return CPPJIT__div__;
 
         } else if (op == "+") {
         // unary positive v.s. addition of two instances
@@ -1274,7 +1274,7 @@ std::string CPyCppyy::Utility::MapOperatorName(const std::string& name, bool bTa
 }
 
 //----------------------------------------------------------------------------
-std::string CPyCppyy::Utility::ClassName(PyObject* pyobj)
+std::string cppjit::cpyrt::Utility::ClassName(PyObject* pyobj)
 {
 // Retrieve the class name from the given Python instance.
     std::string clname = "<unknown>";
@@ -1286,7 +1286,7 @@ std::string CPyCppyy::Utility::ClassName(PyObject* pyobj)
     }
 
     if (pyname) {
-        clname = CPyCppyy_PyText_AsString(pyname);
+        clname = cpyrt_PyText_AsString(pyname);
         Py_DECREF(pyname);
     } else
         PyErr_Clear();
@@ -1295,7 +1295,7 @@ std::string CPyCppyy::Utility::ClassName(PyObject* pyobj)
 
 //----------------------------------------------------------------------------
 static std::set<std::string> sIteratorTypes;
-bool CPyCppyy::Utility::IsSTLIterator(const std::string& classname)
+bool cppjit::cpyrt::Utility::IsSTLIterator(const std::string& classname)
 {
 // attempt to recognize STL iterators (TODO: probably belongs in the backend), using
 // a couple of common container classes with different iterator protocols (note that
@@ -1306,7 +1306,7 @@ bool CPyCppyy::Utility::IsSTLIterator(const std::string& classname)
         std::string tt = "<int>::";
         for (auto c : {"std::vector", "std::list", "std::deque"}) {
             for (auto i : {"iterator", "const_iterator"}) {
-                const std::string& itname = Cppyy::ResolveName(c+tt+i);
+                const std::string& itname = cppjit::interop::ResolveName(c+tt+i);
                 auto pos = itname.find('<');
                 if (pos != std::string::npos)
                     sIteratorTypes.insert(itname.substr(0, pos));
@@ -1322,7 +1322,7 @@ bool CPyCppyy::Utility::IsSTLIterator(const std::string& classname)
 
 
 //----------------------------------------------------------------------------
-CPyCppyy::Utility::PyOperators::~PyOperators()
+cppjit::cpyrt::Utility::PyOperators::~PyOperators()
 {
     Py_XDECREF(fEq);
     Py_XDECREF(fNe);
@@ -1335,7 +1335,7 @@ CPyCppyy::Utility::PyOperators::~PyOperators()
 
 
 //----------------------------------------------------------------------------
-PyObject* CPyCppyy::Utility::PyErr_Occurred_WithGIL()
+PyObject* cppjit::cpyrt::Utility::PyErr_Occurred_WithGIL()
 {
 // Re-acquire the GIL before calling PyErr_Occurred() in case it has been
 // released; note that the p2.2 code assumes that there are no callbacks in
@@ -1348,10 +1348,10 @@ PyObject* CPyCppyy::Utility::PyErr_Occurred_WithGIL()
 
 
 //----------------------------------------------------------------------------
-CPyCppyy::Utility::PyError_t CPyCppyy::Utility::FetchPyError()
+cppjit::cpyrt::Utility::PyError_t cppjit::cpyrt::Utility::FetchPyError()
 {
    // create a PyError_t RAII object that will capture and store the exception data
-   CPyCppyy::Utility::PyError_t error{};
+   cppjit::cpyrt::Utility::PyError_t error{};
 #if PY_VERSION_HEX >= 0x030c0000
    error.fValue.reset(PyErr_GetRaisedException());
 #else
@@ -1368,7 +1368,7 @@ CPyCppyy::Utility::PyError_t CPyCppyy::Utility::FetchPyError()
 
 
 //----------------------------------------------------------------------------
-void CPyCppyy::Utility::RestorePyError(CPyCppyy::Utility::PyError_t &error)
+void cppjit::cpyrt::Utility::RestorePyError(cppjit::cpyrt::Utility::PyError_t &error)
 {
 #if PY_VERSION_HEX >= 0x030c0000
    PyErr_SetRaisedException(error.fValue.release());
@@ -1379,7 +1379,7 @@ void CPyCppyy::Utility::RestorePyError(CPyCppyy::Utility::PyError_t &error)
 
 
 //----------------------------------------------------------------------------
-size_t CPyCppyy::Utility::FetchError(std::vector<PyError_t>& errors, bool is_cpp)
+size_t cppjit::cpyrt::Utility::FetchError(std::vector<PyError_t>& errors, bool is_cpp)
 {
 // Fetch the current python error, if any, and store it for future use.
     if (PyErr_Occurred()) {
@@ -1390,12 +1390,12 @@ size_t CPyCppyy::Utility::FetchError(std::vector<PyError_t>& errors, bool is_cpp
 }
 
 //----------------------------------------------------------------------------
-void CPyCppyy::Utility::SetDetailedException(std::vector<PyError_t>&& errors, PyObject* topmsg, PyObject* defexc)
+void cppjit::cpyrt::Utility::SetDetailedException(std::vector<PyError_t>&& errors, PyObject* topmsg, PyObject* defexc)
 {
 // Use the collected exceptions to build up a detailed error log.
     if (errors.empty()) {
     // should not happen ...
-        PyErr_SetString(defexc, CPyCppyy_PyText_AsString(topmsg));
+        PyErr_SetString(defexc, cpyrt_PyText_AsString(topmsg));
         Py_DECREF(topmsg);
         return;
     }
@@ -1439,29 +1439,29 @@ void CPyCppyy::Utility::SetDetailedException(std::vector<PyError_t>&& errors, Py
         }
 
     // add the details to the topmsg
-        PyObject* separator = CPyCppyy_PyText_FromString("\n  ");
+        PyObject* separator = cpyrt_PyText_FromString("\n  ");
         for (auto& e : errors) {
             PyObject *pyvalue = e.fValue.get();
-            CPyCppyy_PyText_Append(&topmsg, separator);
-            if (CPyCppyy_PyText_Check(pyvalue)) {
-                CPyCppyy_PyText_Append(&topmsg, pyvalue);
+            cpyrt_PyText_Append(&topmsg, separator);
+            if (cpyrt_PyText_Check(pyvalue)) {
+                cpyrt_PyText_Append(&topmsg, pyvalue);
             } else if (pyvalue) {
                 PyObject* excstr = PyObject_Str(pyvalue);
                 if (!excstr) {
                     PyErr_Clear();
                     excstr = PyObject_Str((PyObject*)Py_TYPE(pyvalue));
                 }
-                CPyCppyy_PyText_AppendAndDel(&topmsg, excstr);
+                cpyrt_PyText_AppendAndDel(&topmsg, excstr);
             } else {
-                CPyCppyy_PyText_AppendAndDel(&topmsg,
-                    CPyCppyy_PyText_FromString("unknown exception"));
+                cpyrt_PyText_AppendAndDel(&topmsg,
+                    cpyrt_PyText_FromString("unknown exception"));
             }
         }
 
         Py_DECREF(separator);
 
     // set the python exception
-        PyErr_SetString(exc_type, CPyCppyy_PyText_AsString(topmsg));
+        PyErr_SetString(exc_type, cpyrt_PyText_AsString(topmsg));
     }
 
     Py_DECREF(topmsg);
@@ -1470,17 +1470,17 @@ void CPyCppyy::Utility::SetDetailedException(std::vector<PyError_t>&& errors, Py
 
 //----------------------------------------------------------------------------
 static bool includesDone = false;
-bool CPyCppyy::Utility::IncludePython()
+bool cppjit::cpyrt::Utility::IncludePython()
 {
 // setup Python API for callbacks
     if (!includesDone) {
-        bool okay = Cppyy::Compile(
+        bool okay = cppjit::interop::Compile(
         // basic API (converters etc.)
-            "#include \"CPyCppyy/API.h\"\n"
+            "#include \"cpyrt/API.h\"\n"
 
-        // utilities from the CPyCppyy public API
-            "#include \"CPyCppyy/DispatchPtr.h\"\n"
-            "#include \"CPyCppyy/PyException.h\"\n"
+        // utilities from the cpyrt public API
+            "#include \"cpyrt/DispatchPtr.h\"\n"
+            "#include \"cpyrt/PyException.h\"\n"
         );
         includesDone = okay;
     }
diff --git a/src/CPyCppyy/src/Utility.h b/src/cpyrt/Utility.h
similarity index 92%
rename from src/CPyCppyy/src/Utility.h
rename to src/cpyrt/Utility.h
index cc4c2a5..276fc96 100644
--- a/src/CPyCppyy/src/Utility.h
+++ b/src/cpyrt/Utility.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_UTILITY_H
-#define CPYCPPYY_UTILITY_H
+#ifndef CPYRT_UTILITY_H
+#define CPYRT_UTILITY_H
 
 // Standard
 #include <unordered_map>
@@ -8,9 +8,9 @@
 #include <vector>
 
 #include "Python.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 class PyCallable;
 
@@ -33,9 +33,9 @@ bool AddToClass(PyObject* pyclass, const char* label, PyCallable* pyfunc);
 // helpers for dynamically constructing operators
 PyCallable* FindUnaryOperator(PyObject* pyclass, const char* op);
 PyCallable* FindBinaryOperator(PyObject* left, PyObject* right,
-    const char* op, Cppyy::TCppScope_t scope = Cppyy::TCppScope_t{});
+    const char* op, cppjit::interop::TCppScope_t scope = cppjit::interop::TCppScope_t{});
 PyCallable* FindBinaryOperator(const std::string& lcname, const std::string& rcname,
-    const char* op, Cppyy::TCppScope_t scope = Cppyy::TCppScope_t{}, bool reverse = false);
+    const char* op, cppjit::interop::TCppScope_t scope = cppjit::interop::TCppScope_t{}, bool reverse = false);
 
 // helper for template classes and methods
 enum ArgPreference { kNone, kPointer, kReference, kValue };
@@ -125,6 +125,6 @@ bool IncludePython();
 
 } // namespace Utility
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
-#endif // !CPYCPPYY_UTILITY_H
+#endif // !CPYRT_UTILITY_H
diff --git a/src/CPyCppyy/src/Cppyy.h b/src/cpyrt/cppjit_interop.h
similarity index 81%
rename from src/CPyCppyy/src/Cppyy.h
rename to src/cpyrt/cppjit_interop.h
index 440270c..9753c24 100644
--- a/src/CPyCppyy/src/Cppyy.h
+++ b/src/cpyrt/cppjit_interop.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_CPPYY_H
-#define CPYCPPYY_CPPYY_H
+#ifndef CPYRT_CPPJIT_H
+#define CPYRT_CPPJIT_H
 
 // Standard
 #include <set>
@@ -10,12 +10,12 @@
 
 // import/export (after precommondefs.h from PyPy)
 #ifdef _MSC_VER
-#define CPPYY_IMPORT extern __declspec(dllimport)
+#define CPPJIT_IMPORT extern __declspec(dllimport)
 #else
-#define CPPYY_IMPORT extern
+#define CPPJIT_IMPORT extern
 #endif
 
-// some more types; assumes Cppyy.h follows Python.h
+// some more types; assumes cppjit_interop.h follows Python.h
 #ifndef PY_LONG_LONG
 #ifdef _WIN32
 typedef __int64 PY_LONG_LONG;
@@ -38,7 +38,7 @@ typedef long double PY_LONG_DOUBLE;
 
 // FIXME: We should not duplicate these definitions here and in CppInterOp.h
 // The current setup relies on finding an identical symbol definition in
-// libcppyybackend.so which is fragile and requires updating both locations when
+// libcppjitbackend.so which is fragile and requires updating both locations when
 // changing. Ideally we should have the ability to set/get the template arg info
 // provided through some factory methods in CppInterOp API, so the clients can
 // rely completely on opaque pointers like we do for the rest of the argument
@@ -115,7 +115,7 @@ template <> struct std::hash<Cpp::ObjectRef> {
     }
 };
 
-namespace Cppyy {
+namespace cppjit::interop {
     typedef Cpp::DeclRef TCppScope_t;
     typedef Cpp::TypeRef TCppType_t;
     typedef Cpp::ObjectRef TCppObject_t;
@@ -124,328 +124,328 @@ namespace Cppyy {
     typedef void* TCppFuncAddr_t;
 
 // direct interpreter access -------------------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool Compile(const std::string& code, bool silent = false);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string ToString(TCppScope_t klass, TCppObject_t obj);
 
 // name to opaque C++ scope representation -----------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string ResolveName(const std::string& cppitem_name);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t ResolveType(TCppType_t cppitem_name);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t ResolveEnumReferenceType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t ResolveEnumPointerType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t GetRealType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t GetPointerType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t GetReferencedType(TCppType_t type, bool rvalue = false);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string ResolveEnum(TCppScope_t enum_scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsLValueReferenceType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsRValueReferenceType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsClassType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsIntegerType(TCppType_t type, bool* is_signed = nullptr);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsPointerType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsFunctionPointerType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t GetType(const std::string &name, bool enable_slow_lookup = false);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool AppendTypesSlow(const std::string &name,
-                            std::vector<Cpp::TemplateArgInfo>& types, Cppyy::TCppScope_t parent = nullptr);
-    CPPYY_IMPORT
+                            std::vector<Cpp::TemplateArgInfo>& types, cppjit::interop::TCppScope_t parent = nullptr);
+    CPPJIT_IMPORT
     TCppType_t GetComplexType(const std::string &element_type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetScope(const std::string& scope_name,
                             TCppScope_t parent_scope = TCppScope_t{});
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetUnderlyingScope(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetFullScope(const std::string& scope_name);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetTypeScope(TCppScope_t klass);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetNamed(const std::string& scope_name,
                             TCppScope_t parent_scope = TCppScope_t{});
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetParentScope(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetScopeFromType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t  GetTypeFromScope(TCppScope_t klass);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetGlobalScope();
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetActualClass(TCppScope_t klass, TCppObject_t obj);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     size_t      SizeOf(TCppScope_t klass);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     size_t      SizeOfType(TCppType_t type);
 
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        IsBuiltin(const std::string& type_name);
 
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        IsBuiltin(TCppType_t type);
 
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        IsComplete(TCppScope_t type);
 
 // memory management ---------------------------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppObject_t Allocate(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void         Deallocate(TCppScope_t scope, TCppObject_t instance);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppObject_t Construct(TCppScope_t scope, void* arena = nullptr);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void         Destruct(TCppScope_t scope, TCppObject_t instance);
 
 // method/function dispatching -----------------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void          CallV(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     unsigned char CallB(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     char          CallC(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     short         CallH(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     int           CallI(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     long          CallL(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     PY_LONG_LONG  CallLL(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     float         CallF(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     double        CallD(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     PY_LONG_DOUBLE CallLD(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
 
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void*         CallR(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     char*         CallS(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args, size_t* length);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppObject_t  CallConstructor(TCppMethod_t method, TCppScope_t klass, size_t nargs, void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void          CallDestructor(TCppScope_t type, TCppObject_t self);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppObject_t  CallO(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args, TCppType_t result_type);
 
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppFuncAddr_t GetFunctionAddress(TCppMethod_t method, bool check_enabled=true);
 
 // handling of function argument buffer --------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void*  AllocateFunctionArgs(size_t nargs);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void   DeallocateFunctionArgs(void* args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     size_t GetFunctionArgSizeof();
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     size_t GetFunctionArgTypeoffset();
 
 // scope reflection information ----------------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsNamespace(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsClass(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsTemplate(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsTemplateInstantiation(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsTypedefed(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsAbstract(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsEnumScope(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsEnumConstant(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsEnumType(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsAggregate(TCppScope_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsDefaultConstructable(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsVariable(TCppScope_t scope);
 
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void GetAllCppNames(TCppScope_t scope, std::set<std::string>& cppnames);
 
 // namespace reflection information ------------------------------------------
-    CPPYY_IMPORT
-    std::vector<Cppyy::TCppScope_t> GetUsingNamespaces(TCppScope_t);
+    CPPJIT_IMPORT
+    std::vector<cppjit::interop::TCppScope_t> GetUsingNamespaces(TCppScope_t);
 
 // class reflection information ----------------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetFinalName(TCppScope_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetScopedFinalName(TCppScope_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        HasVirtualDestructor(TCppScope_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppIndex_t GetNumBases(TCppScope_t klass);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppIndex_t GetNumBasesLongestBranch(TCppScope_t klass);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetBaseName(TCppScope_t klass, TCppIndex_t ibase);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t GetBaseScope(TCppScope_t klass, TCppIndex_t ibase);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        IsSubclass(TCppScope_t derived, TCppScope_t base);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        IsSmartPtr(TCppScope_t klass);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        GetSmartPtrInfo(const std::string&, TCppScope_t* raw, TCppMethod_t* deref);
 // calculate offsets between declared and actual type, up-cast: direction > 0; down-cast: direction < 0
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     ptrdiff_t GetBaseOffset(
         TCppScope_t derived, TCppScope_t base, TCppObject_t address, int direction, bool rerror = false);
 
 // method/function reflection information ------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void GetClassMethods(TCppScope_t scope, std::vector<TCppMethod_t> &methods);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::vector<TCppMethod_t> GetMethodsFromName(TCppScope_t scope,
                                                 const std::string& name);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetName(TCppScope_t);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetFullName(TCppScope_t);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t GetMethodReturnType(TCppMethod_t);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetMethodReturnTypeAsString(TCppMethod_t);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppIndex_t GetMethodNumArgs(TCppMethod_t);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppIndex_t GetMethodReqArgs(TCppMethod_t);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetMethodArgName(TCppMethod_t, TCppIndex_t iarg);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t GetMethodArgType(TCppMethod_t, TCppIndex_t iarg);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppIndex_t CompareMethodArgType(TCppMethod_t, TCppIndex_t iarg, const std::string &req_type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetMethodArgTypeAsString(TCppMethod_t method, TCppIndex_t iarg);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetMethodArgCanonTypeAsString(TCppMethod_t method, TCppIndex_t iarg);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetMethodArgDefault(TCppMethod_t, TCppIndex_t iarg);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetMethodSignature(TCppMethod_t, bool show_formal_args, TCppIndex_t max_args = (TCppIndex_t)-1);
     // GetMethodPrototype is unused.
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetMethodPrototype(TCppMethod_t, bool show_formal_args);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetDoxygenComment(TCppScope_t scope, bool strip_markers = true);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        IsConstMethod(TCppMethod_t);
 // Templated method/function reflection information ------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void GetTemplatedMethods(TCppScope_t scope, std::vector<TCppMethod_t> &methods);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppIndex_t GetNumTemplatedMethods(TCppScope_t scope, bool accept_namespace = false);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetTemplatedMethodName(TCppScope_t scope, TCppIndex_t imeth);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        ExistsMethodTemplate(TCppScope_t scope, const std::string& name);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        IsTemplatedMethod(TCppMethod_t method);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool        IsStaticTemplate(TCppScope_t scope, const std::string& name);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppMethod_t GetMethodTemplate(
         TCppScope_t scope, const std::string& name, const std::string& proto);
-    CPPYY_IMPORT
-    void GetClassOperators(Cppyy::TCppScope_t klass, const std::string& opname,
+    CPPJIT_IMPORT
+    void GetClassOperators(cppjit::interop::TCppScope_t klass, const std::string& opname,
                             std::vector<TCppMethod_t>& operators);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppMethod_t  GetGlobalOperator(
         TCppScope_t scope, const std::string& lc, const std::string& rc, const std::string& op);
 
 // method properties ---------------------------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsDeletedMethod(TCppMethod_t method);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsPublicMethod(TCppMethod_t method);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsProtectedMethod(TCppMethod_t method);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsPrivateMethod(TCppMethod_t method);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsConstructor(TCppMethod_t method);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsDestructor(TCppMethod_t method);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsStaticMethod(TCppMethod_t method);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsExplicit(TCppMethod_t method);
 
 // data member reflection information ----------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void GetDatamembers(TCppScope_t scope, std::vector<TCppScope_t>& datamembers);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsLambdaClass(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t WrapLambdaFromVariable(TCppScope_t var);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppMethod_t AdaptFunctionForLambdaReturn(TCppMethod_t fn);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t GetDatamemberType(TCppScope_t data);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetDatamemberTypeAsString(TCppScope_t var);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::string GetTypeAsString(TCppType_t type);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     intptr_t    GetDatamemberOffset(TCppScope_t var, TCppScope_t klass = nullptr);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool CheckDatamember(TCppScope_t scope, const std::string& name);
 
 // // data member properties ----------------------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsPublicData(TCppScope_t var);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsProtectedData(TCppScope_t var);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsPrivateData(TCppScope_t var);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsStaticDatamember(TCppScope_t var);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     bool IsConstVar(TCppScope_t var);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppMethod_t ReduceReturnType(TCppMethod_t fn, TCppType_t reduce);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::vector<long int> GetDimensions(TCppType_t type);
 
 // enum properties -----------------------------------------------------------
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     std::vector<TCppScope_t> GetEnumConstants(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppType_t  GetEnumConstantType(TCppScope_t scope);
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppIndex_t GetEnumDataValue(TCppScope_t scope);
 
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     TCppScope_t InstantiateTemplate(
             TCppScope_t tmpl, Cpp::TemplateArgInfo* args, size_t args_size);
 
-    CPPYY_IMPORT
+    CPPJIT_IMPORT
     void        DumpScope(TCppScope_t scope);
-} // namespace Cppyy
+} // namespace cppjit::interop
 
-#endif // !CPYCPPYY_CPPYY_H
+#endif // !CPYRT_CPPJIT_H
diff --git a/src/CPyCppyy/src/CPyCppyy.h b/src/cpyrt/cpyrt.h
similarity index 55%
rename from src/CPyCppyy/src/CPyCppyy.h
rename to src/cpyrt/cpyrt.h
index 8cf3e35..79da4f7 100644
--- a/src/CPyCppyy/src/CPyCppyy.h
+++ b/src/cpyrt/cpyrt.h
@@ -1,5 +1,5 @@
-#ifndef CPYCPPYY_CPYCPPYY_H
-#define CPYCPPYY_CPYCPPYY_H
+#ifndef CPYRT_CPYRT_H
+#define CPYRT_CPYRT_H
 
 #ifdef _WIN32
 // Disable warning C4275: non dll-interface class
@@ -35,9 +35,9 @@
 #include "Python.h"
 #include <sys/types.h>
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     typedef Py_ssize_t dim_t;
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 
 #if PY_VERSION_HEX >= 0x030b0000
    typedef Py_ssize_t (*dict_lookup_func)(
@@ -48,25 +48,25 @@ namespace CPyCppyy {
 #endif
 
 // for 3.0 support (backwards compatibility, really)
-#define CPyCppyy_PyText_Check              PyUnicode_Check
-#define CPyCppyy_PyText_CheckExact         PyUnicode_CheckExact
-#define CPyCppyy_PyText_AsString           PyUnicode_AsUTF8
-#define CPyCppyy_PyText_AsStringChecked    PyUnicode_AsUTF8
-#define CPyCppyy_PyText_GetSize            PyUnicode_GetSize
-#define CPyCppyy_PyText_GET_SIZE           PyUnicode_GET_LENGTH
-#define CPyCppyy_PyUnicode_GET_SIZE        PyUnicode_GET_LENGTH
-#define CPyCppyy_PyText_FromFormat         PyUnicode_FromFormat
-#define CPyCppyy_PyText_FromString         PyUnicode_FromString
-#define CPyCppyy_PyText_InternFromString   PyUnicode_InternFromString
-#define CPyCppyy_PyText_Append             PyUnicode_Append
-#define CPyCppyy_PyText_AppendAndDel       PyUnicode_AppendAndDel
-#define CPyCppyy_PyText_FromStringAndSize  PyUnicode_FromStringAndSize
-
-#define _CPyCppyy_PyText_AsStringAndSize   PyUnicode_AsUTF8AndSize
-
-static inline const char* CPyCppyy_PyText_AsStringAndSize(PyObject* pystr, Py_ssize_t* size)
+#define cpyrt_PyText_Check              PyUnicode_Check
+#define cpyrt_PyText_CheckExact         PyUnicode_CheckExact
+#define cpyrt_PyText_AsString           PyUnicode_AsUTF8
+#define cpyrt_PyText_AsStringChecked    PyUnicode_AsUTF8
+#define cpyrt_PyText_GetSize            PyUnicode_GetSize
+#define cpyrt_PyText_GET_SIZE           PyUnicode_GET_LENGTH
+#define cpyrt_PyUnicode_GET_SIZE        PyUnicode_GET_LENGTH
+#define cpyrt_PyText_FromFormat         PyUnicode_FromFormat
+#define cpyrt_PyText_FromString         PyUnicode_FromString
+#define cpyrt_PyText_InternFromString   PyUnicode_InternFromString
+#define cpyrt_PyText_Append             PyUnicode_Append
+#define cpyrt_PyText_AppendAndDel       PyUnicode_AppendAndDel
+#define cpyrt_PyText_FromStringAndSize  PyUnicode_FromStringAndSize
+
+#define _cpyrt_PyText_AsStringAndSize   PyUnicode_AsUTF8AndSize
+
+static inline const char* cpyrt_PyText_AsStringAndSize(PyObject* pystr, Py_ssize_t* size)
 {
-    const char* cstr = _CPyCppyy_PyText_AsStringAndSize(pystr, size);
+    const char* cstr = _cpyrt_PyText_AsStringAndSize(pystr, size);
     if (!cstr && PyBytes_CheckExact(pystr)) {
         PyErr_Clear();
         PyBytes_AsStringAndSize(pystr, (char**)&cstr, size);
@@ -74,7 +74,7 @@ static inline const char* CPyCppyy_PyText_AsStringAndSize(PyObject* pystr, Py_ss
     return cstr;
 }
 
-#define CPyCppyy_PyText_Type PyUnicode_Type
+#define cpyrt_PyText_Type PyUnicode_Type
 
 #define PyIntObject          PyLongObject
 #define PyInt_Check          PyLong_Check
@@ -87,14 +87,14 @@ static inline const char* CPyCppyy_PyText_AsStringAndSize(PyObject* pystr, Py_ss
 
 #define PyInt_Type      PyLong_Type
 
-#define CPyCppyy_PyCapsule_New           PyCapsule_New
-#define CPyCppyy_PyCapsule_CheckExact    PyCapsule_CheckExact
-#define CPyCppyy_PyCapsule_GetPointer    PyCapsule_GetPointer
+#define cpyrt_PyCapsule_New           PyCapsule_New
+#define cpyrt_PyCapsule_CheckExact    PyCapsule_CheckExact
+#define cpyrt_PyCapsule_GetPointer    PyCapsule_GetPointer
 
-#define CPPYY__long__ "__int__"
-#define CPPYY__idiv__ "__itruediv__"
-#define CPPYY__div__  "__truediv__"
-#define CPPYY__next__ "__next__"
+#define CPPJIT__long__ "__int__"
+#define CPPJIT__idiv__ "__itruediv__"
+#define CPPJIT__div__  "__truediv__"
+#define CPPJIT__next__ "__next__"
 
 #define Py_TPFLAGS_HAVE_RICHCOMPARE 0
 #define Py_TPFLAGS_CHECKTYPES 0
@@ -103,10 +103,10 @@ static inline const char* CPyCppyy_PyText_AsStringAndSize(PyObject* pystr, Py_ss
 
 #define PyBuffer_Type   PyMemoryView_Type
 
-#define CPyCppyy_PySliceCast   PyObject*
+#define cpyrt_PySliceCast   PyObject*
 #define PyUnicode_GetSize      PyUnicode_GetLength
 
-#define CPyCppyy_PyUnicode_AsWideChar PyUnicode_AsWideChar
+#define cpyrt_PyUnicode_AsWideChar PyUnicode_AsWideChar
 
 #ifdef R__MACOSX
 # if SIZEOF_SIZE_T == SIZEOF_INT
@@ -135,28 +135,28 @@ static inline const char* CPyCppyy_PyText_AsStringAndSize(PyObject* pystr, Py_ss
 #endif
 
 // vector call support
-#define CPyCppyy_PyCFunction_Call PyObject_Call
+#define cpyrt_PyCFunction_Call PyObject_Call
 
 // vector call support
-typedef PyObject* const* CPyCppyy_PyArgs_t;
-static inline PyObject* CPyCppyy_PyArgs_GET_ITEM(CPyCppyy_PyArgs_t args, Py_ssize_t i) {
+typedef PyObject* const* cpyrt_PyArgs_t;
+static inline PyObject* cpyrt_PyArgs_GET_ITEM(cpyrt_PyArgs_t args, Py_ssize_t i) {
     return args[i];
 }
-static inline PyObject* CPyCppyy_PyArgs_SET_ITEM(CPyCppyy_PyArgs_t args, Py_ssize_t i, PyObject* item) {
+static inline PyObject* cpyrt_PyArgs_SET_ITEM(cpyrt_PyArgs_t args, Py_ssize_t i, PyObject* item) {
     return ((PyObject**)args)[i] = item;
 }
-static inline Py_ssize_t CPyCppyy_PyArgs_GET_SIZE(CPyCppyy_PyArgs_t, size_t nargsf) {
+static inline Py_ssize_t cpyrt_PyArgs_GET_SIZE(cpyrt_PyArgs_t, size_t nargsf) {
     return PyVectorcall_NARGS(nargsf);
 }
-static inline CPyCppyy_PyArgs_t CPyCppyy_PyArgs_New(Py_ssize_t N) {
-    return (CPyCppyy_PyArgs_t)PyMem_Malloc(N*sizeof(PyObject*));
+static inline cpyrt_PyArgs_t cpyrt_PyArgs_New(Py_ssize_t N) {
+    return (cpyrt_PyArgs_t)PyMem_Malloc(N*sizeof(PyObject*));
 }
-static inline void CPyCppyy_PyArgs_DEL(CPyCppyy_PyArgs_t args) {
+static inline void cpyrt_PyArgs_DEL(cpyrt_PyArgs_t args) {
     PyMem_Free((void*)args);
 }
-#define CPyCppyy_PyObject_Call  PyObject_Vectorcall
-inline PyObject* CPyCppyy_tp_call(
-        PyObject* cb, CPyCppyy_PyArgs_t args, size_t nargsf, PyObject* kwds) {
+#define cpyrt_PyObject_Call  PyObject_Vectorcall
+inline PyObject* cpyrt_tp_call(
+        PyObject* cb, cpyrt_PyArgs_t args, size_t nargsf, PyObject* kwds) {
     Py_ssize_t offset = Py_TYPE(cb)->tp_vectorcall_offset;
     vectorcallfunc func = *(vectorcallfunc*)(((char*)cb) + offset);
     return func(cb, args, nargsf, kwds);
@@ -168,7 +168,7 @@ inline PyObject* CPyCppyy_tp_call(
 
 // weakref forced strong reference
 #if PY_VERSION_HEX < 0x30d0000
-static inline PyObject* CPyCppyy_GetWeakRef(PyObject* ref) {
+static inline PyObject* cpyrt_GetWeakRef(PyObject* ref) {
     PyObject* pyobject = PyWeakref_GetObject(ref);
     if (!pyobject || pyobject == Py_None)
         return nullptr;
@@ -176,7 +176,7 @@ static inline PyObject* CPyCppyy_GetWeakRef(PyObject* ref) {
     return pyobject;
 }
 #else
-static inline PyObject* CPyCppyy_GetWeakRef(PyObject* ref) {
+static inline PyObject* cpyrt_GetWeakRef(PyObject* ref) {
     PyObject* pyobject = nullptr;
     if (PyWeakref_GetRef(ref, &pyobject) != -1)
         return pyobject;
@@ -184,40 +184,40 @@ static inline PyObject* CPyCppyy_GetWeakRef(PyObject* ref) {
 }
 #endif
 
-// C++ version of the cppyy API
-#include "Cppyy.h"
+// C++ version of the cppjit API
+#include "cppjit_interop.h"
 
 // export macros for our own API
-#include "CPyCppyy/CommonDefs.h"
+#include "cpyrt/CommonDefs.h"
 
 // --- reusable PyTypeObject initializer tail -------------------------------
-// Members appended to PyTypeObject in newer CPython releases. Every CPyCppyy
+// Members appended to PyTypeObject in newer CPython releases. Every cpyrt
 // type leaves all of these zero/null-initialized, so they share one tail.
 // To support a future Python version, add one block below and one line to
-// CPYCPPYY_PYTYPE_TAIL.
+// CPYRT_PYTYPE_TAIL.
 
 #if PY_VERSION_HEX >= 0x030c0000
-#define CPYCPPYY_TP_WATCHED        , 0          /* tp_watched      (>= 3.12) */
+#define CPYRT_TP_WATCHED        , 0          /* tp_watched      (>= 3.12) */
 #else
-#define CPYCPPYY_TP_WATCHED
+#define CPYRT_TP_WATCHED
 #endif
 
 #if PY_VERSION_HEX >= 0x030d0000
-#define CPYCPPYY_TP_VERSIONS_USED  , 0          /* tp_versions_used(>= 3.13) */
+#define CPYRT_TP_VERSIONS_USED  , 0          /* tp_versions_used(>= 3.13) */
 #else
-#define CPYCPPYY_TP_VERSIONS_USED
+#define CPYRT_TP_VERSIONS_USED
 #endif
 
 #if PY_VERSION_HEX >= 0x030f0000
-#define CPYCPPYY_TP_ITERITEM       , nullptr    /* _tp_iteritem    (>= 3.15) */
+#define CPYRT_TP_ITERITEM       , nullptr    /* _tp_iteritem    (>= 3.15) */
 #else
-#define CPYCPPYY_TP_ITERITEM
+#define CPYRT_TP_ITERITEM
 #endif
 
-#define CPYCPPYY_PYTYPE_TAIL \
-    CPYCPPYY_TP_WATCHED \
-    CPYCPPYY_TP_VERSIONS_USED \
-    CPYCPPYY_TP_ITERITEM
+#define CPYRT_PYTYPE_TAIL \
+    CPYRT_TP_WATCHED \
+    CPYRT_TP_VERSIONS_USED \
+    CPYRT_TP_ITERITEM
 // --------------------------------------------------------------------------
 
-#endif // !CPYCPPYY_CPYCPPYY_H
+#endif // !CPYRT_CPYRT_H
diff --git a/src/CPyCppyy/src/CPyCppyyModule.cxx b/src/cpyrt/cpyrtModule.cxx
similarity index 85%
rename from src/CPyCppyy/src/CPyCppyyModule.cxx
rename to src/cpyrt/cpyrtModule.cxx
index 21b0232..e6950f6 100644
--- a/src/CPyCppyy/src/CPyCppyyModule.cxx
+++ b/src/cpyrt/cpyrtModule.cxx
@@ -1,5 +1,5 @@
 // Bindings
-#include "CPyCppyy.h"
+#include "cpyrt.h"
 #include "CallContext.h"
 #include "Converters.h"
 #include "CPPDataMember.h"
@@ -7,7 +7,7 @@
 #include "CPPInstance.h"
 #include "CPPOverload.h"
 #include "CPPScope.h"
-#include "Cppyy.h"
+#include "cppjit_interop.h"
 #include "CustomPyTypes.h"
 #include "LowLevelViews.h"
 #include "MemoryRegulator.h"
@@ -18,14 +18,14 @@
 #include "Utility.h"
 #include <unordered_map>
 
-#define CPYCPPYY_INTERNAL 1
-#include "CPyCppyy/DispatchPtr.h"
-namespace CPyCppyy {
+#define CPYRT_INTERNAL 1
+#include "cpyrt/DispatchPtr.h"
+namespace cppjit::cpyrt {
 void* Instance_AsVoidPtr(PyObject* pyobject);
 PyObject* Instance_FromVoidPtr(
     void* addr, const std::string& classname, bool python_owns = false);
-} // namespace CPyCppyy
-#undef CPYCPPYY_INTERNAL
+} // namespace cppjit::cpyrt
+#undef CPYRT_INTERNAL
 
 // Standard
 #include <algorithm>
@@ -38,16 +38,16 @@ PyObject* Instance_FromVoidPtr(
 #include <vector>
 
 #if PY_VERSION_HEX < 0x030b0000
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 extern dict_lookup_func gDictLookupOrg;
 dict_lookup_func gDictLookupOrg = nullptr;
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
 #endif
 
-std::unordered_map<Cppyy::TCppType_t, Cppyy::TCppType_t> TypeReductionMap;
+std::unordered_map<cppjit::interop::TCppType_t, cppjit::interop::TCppType_t> TypeReductionMap;
 
 // Note: as of py3.11, dictionary objects no longer carry a function pointer for
-// the lookup, so it can no longer be shimmed and "from cppyy.interactive import *"
+// the lookup, so it can no longer be shimmed and "from cppjit.interactive import *"
 // thus no longer works.
 #if PY_VERSION_HEX < 0x030b0000
 
@@ -75,7 +75,7 @@ std::unordered_map<Cppyy::TCppType_t, Cppyy::TCppType_t> TypeReductionMap;
         } dk_indices;
     } PyDictKeysObject;
 
-#define CPYCPPYY_GET_DICT_LOOKUP(mp)                                          \
+#define CPYRT_GET_DICT_LOOKUP(mp)                                          \
     ((dict_lookup_func&)mp->ma_keys->dk_lookup)
 
 #endif // PY_VERSION_HEX < 0x030b0000
@@ -83,7 +83,7 @@ std::unordered_map<Cppyy::TCppType_t, Cppyy::TCppType_t> TypeReductionMap;
 //- data -----------------------------------------------------------------------
 static PyObject* nullptr_repr(PyObject*)
 {
-    return CPyCppyy_PyText_FromString("nullptr");
+    return cpyrt_PyText_FromString("nullptr");
 }
 
 static void nullptr_dealloc(PyObject*)
@@ -133,13 +133,13 @@ static PyTypeObject PyNullPtr_t_Type = {
     0,                   // tp_version_tag
     0,                   // tp_finalize
     0                    // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
 
 static PyObject* default_repr(PyObject*)
 {
-    return CPyCppyy_PyText_FromString("type default");
+    return cpyrt_PyText_FromString("type default");
 }
 
 static void default_dealloc(PyObject*)
@@ -167,21 +167,21 @@ static PyTypeObject PyDefault_t_Type = {
     0,                  // tp_version_tag
     0,                  // tp_finalize
     0                   // tp_vectorcall
-    CPYCPPYY_PYTYPE_TAIL
+    CPYRT_PYTYPE_TAIL
 };
 
 namespace {
 
 struct {
    PyObject_HEAD
-} _CPyCppyy_NullPtrStruct{PyObject_HEAD_INIT(&PyNullPtr_t_Type)};
+} _cpyrt_NullPtrStruct{PyObject_HEAD_INIT(&PyNullPtr_t_Type)};
 
 struct {
    PyObject_HEAD
-} _CPyCppyy_DefaultStruct{PyObject_HEAD_INIT(&PyDefault_t_Type)};
+} _cpyrt_DefaultStruct{PyObject_HEAD_INIT(&PyDefault_t_Type)};
 
 // TODO: refactor with Converters.cxx
-struct CPyCppyy_tagCDataObject {       // non-public (but stable)
+struct cpyrt_tagCDataObject {       // non-public (but stable)
     PyObject_HEAD
     char* b_ptr;
     int   b_needsfree;
@@ -189,7 +189,7 @@ struct CPyCppyy_tagCDataObject {       // non-public (but stable)
 
 } // unnamed namespace
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
     PyObject* gThisModule    = nullptr;
     PyObject* gPyTypeMap     = nullptr;
     PyObject* gNullPtrObject = nullptr;
@@ -198,7 +198,7 @@ namespace CPyCppyy {
     PyObject* gSegvException = nullptr;
     PyObject* gIllException  = nullptr;
     PyObject* gAbrtException = nullptr;
-    std::unordered_set<Cppyy::TCppScope_t> gPinnedTypes;
+    std::unordered_set<cppjit::interop::TCppScope_t> gPinnedTypes;
     std::ostringstream gCapturedError;
     std::streambuf* gOldErrorBuffer = nullptr;
 
@@ -213,7 +213,7 @@ namespace CPyCppyy {
 //- private helpers ------------------------------------------------------------
 namespace {
 
-using namespace CPyCppyy;
+using namespace cppjit::cpyrt;
 
 
 //----------------------------------------------------------------------------
@@ -223,8 +223,8 @@ namespace {
 class GblGetter {
 public:
     GblGetter() {
-        PyObject* cppyy = PyImport_AddModule((char*)"cppyy");
-        fGbl = PyObject_GetAttrString(cppyy, (char*)"gbl");
+        PyObject* cppjit = PyImport_AddModule((char*)"cppjit");
+        fGbl = PyObject_GetAttrString(cppjit, (char*)"gbl");
     }
     ~GblGetter() { Py_DECREF(fGbl); }
 
@@ -241,17 +241,17 @@ inline Py_ssize_t OrgDictLookup(PyDictObject* mp, PyObject* key,
 {
     return (*gDictLookupOrg)(mp, key, hash, value_addr, hashpos);
 }
-#define CPYCPPYY_ORGDICT_LOOKUP(mp, key, hash, value_addr, hashpos)           \
+#define CPYRT_ORGDICT_LOOKUP(mp, key, hash, value_addr, hashpos)           \
     OrgDictLookup(mp, key, hash, value_addr, hashpos)
 
-Py_ssize_t CPyCppyyLookDictString(PyDictObject* mp, PyObject* key,
+Py_ssize_t cpyrtLookDictString(PyDictObject* mp, PyObject* key,
     Py_hash_t hash, PyObject*** value_addr, Py_ssize_t* hashpos)
 {
     static GblGetter gbl;
     Py_ssize_t ep;
 
 // first search dictionary itself
-    ep = CPYCPPYY_ORGDICT_LOOKUP(mp, key, hash, value_addr, hashpos);
+    ep = CPYRT_ORGDICT_LOOKUP(mp, key, hash, value_addr, hashpos);
     if (gDictLookupActive)
         return ep;
 
@@ -282,13 +282,13 @@ Py_ssize_t CPyCppyyLookDictString(PyDictObject* mp, PyObject* key,
         }
 
     // add reference to C++ entity in the given dictionary
-        CPYCPPYY_GET_DICT_LOOKUP(mp) = gDictLookupOrg;      // prevent recursion
+        CPYRT_GET_DICT_LOOKUP(mp) = gDictLookupOrg;      // prevent recursion
         if (PyDict_SetItem((PyObject*)mp, key, val) == 0) {
-            ep = CPYCPPYY_ORGDICT_LOOKUP(mp, key, hash, value_addr, hashpos);
+            ep = CPYRT_ORGDICT_LOOKUP(mp, key, hash, value_addr, hashpos);
         } else {
             ep = -1;
         }
-        CPYCPPYY_GET_DICT_LOOKUP(mp) = CPyCppyyLookDictString;   // restore
+        CPYRT_GET_DICT_LOOKUP(mp) = cpyrtLookDictString;   // restore
 
     // done with val
         Py_DECREF(val);
@@ -299,12 +299,12 @@ Py_ssize_t CPyCppyyLookDictString(PyDictObject* mp, PyObject* key,
     // big risk that this lookup will result in a resize, so force it here
     // to be able to reset the lookup function; of course, this is nowhere
     // near fool-proof, but should cover interactive usage ...
-        CPYCPPYY_GET_DICT_LOOKUP(mp) = gDictLookupOrg;
+        CPYRT_GET_DICT_LOOKUP(mp) = gDictLookupOrg;
         const int maxinsert = 5;
         PyObject* buf[maxinsert];
         for (int varmax = 1; varmax <= maxinsert; ++varmax) {
             for (int ivar = 0; ivar < varmax; ++ivar) {
-                buf[ivar] = CPyCppyy_PyText_FromFormat("__CPYCPPYY_FORCE_RESIZE_%d", ivar);
+                buf[ivar] = cpyrt_PyText_FromFormat("__CPYRT_FORCE_RESIZE_%d", ivar);
                 PyDict_SetItem((PyObject*)mp, buf[ivar], Py_None);
             }
             for (int ivar = 0; ivar < varmax; ++ivar) {
@@ -316,11 +316,11 @@ Py_ssize_t CPyCppyyLookDictString(PyDictObject* mp, PyObject* key,
         }
 
     // make sure the entry pointer is still valid by re-doing the lookup
-        ep = CPYCPPYY_ORGDICT_LOOKUP(mp, key, hash, value_addr, hashpos);
+        ep = CPYRT_ORGDICT_LOOKUP(mp, key, hash, value_addr, hashpos);
 
     // full reset of all lookup functions
-        gDictLookupOrg = CPYCPPYY_GET_DICT_LOOKUP(mp);
-        CPYCPPYY_GET_DICT_LOOKUP(mp) = CPyCppyyLookDictString;   // restore
+        gDictLookupOrg = CPYRT_GET_DICT_LOOKUP(mp);
+        CPYRT_GET_DICT_LOOKUP(mp) = cpyrtLookDictString;   // restore
     }
 
 // stopped calling into the reflection system
@@ -343,7 +343,7 @@ static PyObject* SetCppLazyLookup(PyObject*, PyObject* args)
     if (!PyArg_ParseTuple(args, const_cast<char*>("O!"), &PyDict_Type, &dict))
         return nullptr;
 
-    CPYCPPYY_GET_DICT_LOOKUP(dict) = CPyCppyyLookDictString;
+    CPYRT_GET_DICT_LOOKUP(dict) = cpyrtLookDictString;
 #else
 // As of py3.11, there is no longer a lookup function pointer in the dict object
 // to replace. Since this feature is not widely advertised, it's simply dropped
@@ -375,8 +375,8 @@ static PyObject* MakeCppTemplateClass(PyObject* /* self */, PyObject* args)
     if (PyErr_Occurred())
       return nullptr;
 
-    Cppyy::TCppScope_t scope = 
-        Cppyy::InstantiateTemplate(tmpl, types.data(), types.size());
+    cppjit::interop::TCppScope_t scope = 
+        cppjit::interop::InstantiateTemplate(tmpl, types.data(), types.size());
     for (Cpp::TemplateArgInfo i: types) {
         if (i.m_IntegralValue)
             std::free((void*)i.m_IntegralValue);
@@ -385,8 +385,8 @@ static PyObject* MakeCppTemplateClass(PyObject* /* self */, PyObject* args)
     if (!scope) {
       PyErr_Format(PyExc_TypeError,
                    "Template instantiation failed: '%s' with args: '%s\n'",
-                   Cppyy::GetScopedFinalName(tmpl).c_str(),
-                   CPyCppyy_PyText_AsString(PyObject_Repr(args)));
+                   cppjit::interop::GetScopedFinalName(tmpl).c_str(),
+                   cpyrt_PyText_AsString(PyObject_Repr(args)));
       return nullptr;
     }
 
@@ -400,7 +400,7 @@ static void* GetCPPInstanceAddress(const char* fname, PyObject* args, PyObject*
 // Helper to get the address (address-of-address) of various object proxy types.
     CPPInstance* pyobj = 0; PyObject* pyname = 0; int byref = 0;
     if (PyArg_ParseTupleAndKeywords(args, kwds, const_cast<char*>("O|O!b"), GCIA_kwlist,
-            &pyobj, &CPyCppyy_PyText_Type, &pyname, &byref)) {
+            &pyobj, &cpyrt_PyText_Type, &pyname, &byref)) {
 
         if (CPPInstance_Check(pyobj)) {
             if (pyname != 0) {
@@ -422,7 +422,7 @@ static void* GetCPPInstanceAddress(const char* fname, PyObject* args, PyObject*
                 Py_XDECREF(pyprop);
 
                 PyErr_Format(PyExc_TypeError,
-                    "%s is not a valid data member", CPyCppyy_PyText_AsString(pyname));
+                    "%s is not a valid data member", cpyrt_PyText_AsString(pyname));
                 return nullptr;
             }
 
@@ -431,9 +431,9 @@ static void* GetCPPInstanceAddress(const char* fname, PyObject* args, PyObject*
             if (!byref) return ((CPPInstance*)pyobj)->GetObject();
             return &((CPPInstance*)pyobj)->GetObjectRaw();
 
-        } else if (CPyCppyy_PyText_Check(pyobj)) {
-        // special cases for access to the CPyCppyy API
-            std::string req = CPyCppyy_PyText_AsString((PyObject*)pyobj);
+        } else if (cpyrt_PyText_Check(pyobj)) {
+        // special cases for access to the cpyrt API
+            std::string req = cpyrt_PyText_AsString((PyObject*)pyobj);
             if (req == "Instance_AsVoidPtr")
                 return (void*)&Instance_AsVoidPtr;
             else if (req == "Instance_FromVoidPtr")
@@ -449,7 +449,7 @@ static void* GetCPPInstanceAddress(const char* fname, PyObject* args, PyObject*
 //----------------------------------------------------------------------------
 static PyObject* addressof(PyObject* /* dummy */, PyObject* args, PyObject* kwds)
 {
-// Return object proxy address as a value (cppyy-style), or the same for an array.
+// Return object proxy address as a value (cppjit-style), or the same for an array.
     void* addr = GetCPPInstanceAddress("addressof", args, kwds);
     if (addr)
         return PyLong_FromLongLong((intptr_t)addr);
@@ -471,7 +471,7 @@ static PyObject* addressof(PyObject* /* dummy */, PyObject* args, PyObject* kwds
                 return nullptr;
             }
 
-            Cppyy::TCppFuncAddr_t caddr = methods[0]->GetFunctionAddress();
+            cppjit::interop::TCppFuncAddr_t caddr = methods[0]->GetFunctionAddress();
             return PyLong_FromLongLong((intptr_t)caddr);
         }
 
@@ -496,8 +496,8 @@ static PyObject* addressof(PyObject* /* dummy */, PyObject* args, PyObject* kwds
     if (!PyErr_Occurred()) {
         if (PyTuple_CheckExact(args) && PyTuple_GET_SIZE(args)) {
             PyObject* str = PyObject_Str(PyTuple_GET_ITEM(args, 0));
-            if (str && CPyCppyy_PyText_Check(str))
-                PyErr_Format(PyExc_TypeError, "unknown object %s", CPyCppyy_PyText_AsString(str));
+            if (str && cpyrt_PyText_Check(str))
+                PyErr_Format(PyExc_TypeError, "unknown object %s", cpyrt_PyText_AsString(str));
             else
                 PyErr_Format(PyExc_TypeError, "unknown object at %p", (void*)PyTuple_GET_ITEM(args, 0));
             Py_XDECREF(str);
@@ -512,7 +512,7 @@ static PyObject* AsCObject(PyObject* /* unused */, PyObject* args, PyObject* kwd
 // Return object proxy as an opaque CObject.
     void* addr = GetCPPInstanceAddress("as_cobject", args, kwds);
     if (addr)
-        return CPyCppyy_PyCapsule_New((void*)addr, nullptr, nullptr);
+        return cpyrt_PyCapsule_New((void*)addr, nullptr, nullptr);
     return nullptr;
 }
 
@@ -547,8 +547,8 @@ static PyObject* AsCTypes(PyObject* /* unused */, PyObject* args, PyObject* kwds
     }
 
     PyObject* ref = ct_cvoidp->tp_new(ct_cvoidp, nullptr, nullptr);
-    *(void**)((CPyCppyy_tagCDataObject*)ref)->b_ptr = addr;
-    ((CPyCppyy_tagCDataObject*)ref)->b_needsfree = 0;
+    *(void**)((cpyrt_tagCDataObject*)ref)->b_ptr = addr;
+    ((cpyrt_tagCDataObject*)ref)->b_needsfree = 0;
     return ref;
 }
 
@@ -562,11 +562,11 @@ static PyObject* AsMemoryView(PyObject* /* unused */, PyObject* pyobject)
     }
 
     CPPInstance* pyobj = (CPPInstance*)pyobject;
-    Cppyy::TCppScope_t klass = ((CPPClass*)Py_TYPE(pyobject))->fCppType;
+    cppjit::interop::TCppScope_t klass = ((CPPClass*)Py_TYPE(pyobject))->fCppType;
 
     Py_ssize_t array_len = pyobj->ArrayLength();
 
-    if (array_len < 0 || !Cppyy::IsAggregate(klass)) {
+    if (array_len < 0 || !cppjit::interop::IsAggregate(klass)) {
         PyErr_SetString(
             PyExc_TypeError, "object is not a proxy to an array of PODs of known size");
         return nullptr;
@@ -576,7 +576,7 @@ static PyObject* AsMemoryView(PyObject* /* unused */, PyObject* pyobject)
 
     view.obj            = pyobject;
     view.buf            = pyobj->GetObject();
-    view.itemsize       = Cppyy::SizeOf(klass);
+    view.itemsize       = cppjit::interop::SizeOf(klass);
     view.len            = view.itemsize * array_len;
     view.readonly       = 0;
     view.format         = NULL;   // i.e. "B" assumed
@@ -601,9 +601,9 @@ static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds)
     }
 
 // convert 2nd argument first (used for both pointer value and instance cases)
-    Cppyy::TCppScope_t cast_type = nullptr;
+    cppjit::interop::TCppScope_t cast_type = nullptr;
     PyObject* arg1 = PyTuple_GET_ITEM(args, 1);
-    if (!CPyCppyy_PyText_Check(arg1)) {          // not string, then class
+    if (!cpyrt_PyText_Check(arg1)) {          // not string, then class
         if (CPPScope_Check(arg1))
             cast_type = ((CPPClass*)arg1)->fCppType;
         else
@@ -612,7 +612,7 @@ static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds)
         Py_INCREF(arg1);
 
     if (!cast_type && arg1) {
-        cast_type = (Cppyy::TCppScope_t)Cppyy::GetScope(CPyCppyy_PyText_AsString(arg1));
+        cast_type = (cppjit::interop::TCppScope_t)cppjit::interop::GetScope(cpyrt_PyText_AsString(arg1));
         Py_DECREF(arg1);
     }
 
@@ -629,7 +629,7 @@ static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds)
     // if this instance's class has a relation to the requested one, calculate the
     // offset, erase if from any caches, and update the pointer and type
         CPPInstance* arg0_pyobj = (CPPInstance*)arg0;
-        Cppyy::TCppScope_t cur_type = arg0_pyobj->ObjectIsA(false /* check_smart */);
+        cppjit::interop::TCppScope_t cur_type = arg0_pyobj->ObjectIsA(false /* check_smart */);
 
         bool isPython = CPPScope_Check(arg1) && \
             (((CPPClass*)arg1)->fFlags & CPPScope::kIsPython);
@@ -640,12 +640,12 @@ static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds)
         }
 
         int direction = 0;
-        Cppyy::TCppScope_t base = nullptr, derived = nullptr;
-        if (Cppyy::IsSubclass(cast_type, cur_type)) {
+        cppjit::interop::TCppScope_t base = nullptr, derived = nullptr;
+        if (cppjit::interop::IsSubclass(cast_type, cur_type)) {
             derived = cast_type;
             base    = cur_type;
             direction = -1;      // down-cast
-        } else if (Cppyy::IsSubclass(cur_type, cast_type)) {
+        } else if (cppjit::interop::IsSubclass(cur_type, cast_type)) {
             base    = cast_type;
             derived = cur_type;
             direction =  1;      // up-cast
@@ -655,8 +655,8 @@ static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds)
             return nullptr;
         }
 
-        Cppyy::TCppObject_t address = (Cppyy::TCppObject_t)arg0_pyobj->GetObject();
-        ptrdiff_t offset = Cppyy::GetBaseOffset(derived, base, address, direction);
+        cppjit::interop::TCppObject_t address = (cppjit::interop::TCppObject_t)arg0_pyobj->GetObject();
+        ptrdiff_t offset = cppjit::interop::GetBaseOffset(derived, base, address, direction);
 
     // it's debatable whether a new proxy should be created rather than updating
     // the old, but changing the old object would be changing the behavior of all
@@ -670,7 +670,7 @@ static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds)
         if (!isPython) {
         // ordinary C++ class
             PyObject* pyobj = BindCppObjectNoCast(
-                Cppyy::TCppObject_t((void*)((intptr_t)address.data + offset)), cast_type, owns ? CPPInstance::kIsOwner : 0);
+                cppjit::interop::TCppObject_t((void*)((intptr_t)address.data + offset)), cast_type, owns ? CPPInstance::kIsOwner : 0);
             if (owns && pyobj) arg0_pyobj->CppOwns();
             return pyobj;
 
@@ -681,7 +681,7 @@ static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds)
             PyObject* pyobj = ((PyTypeObject*)arg1)->tp_new((PyTypeObject*)arg1, nullptr, nullptr);
             ((CPPInstance*)pyobj)->GetObjectRaw() = cast_address;
 
-            PyObject* dispproxy = CPyCppyy::GetScopeProxy(cast_type);
+            PyObject* dispproxy = cppjit::cpyrt::GetScopeProxy(cast_type);
             PyObject* res = PyObject_CallMethodOneArg(dispproxy, PyStrings::gDispGet, pyobj);
             /* Note: the resultant object is borrowed */
             if (CPPInstance_Check(res) && ((CPPInstance*)res)->GetObject() == cast_address) {
@@ -706,7 +706,7 @@ static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds)
 // not a pre-existing object; get the address and bind
     void* addr = nullptr;
     if (arg0 != gNullPtrObject) {
-        addr = CPyCppyy_PyCapsule_GetPointer(arg0, nullptr);
+        addr = cpyrt_PyCapsule_GetPointer(arg0, nullptr);
         if (PyErr_Occurred()) {
             PyErr_Clear();
 
@@ -763,7 +763,7 @@ static PyObject* AddPythonization(PyObject*, PyObject* args)
     if (!PyCallable_Check(pythonizor)) {
         PyObject* pystr = PyObject_Str(pythonizor);
         PyErr_Format(PyExc_TypeError,
-            "given \'%s\' object is not callable", CPyCppyy_PyText_AsString(pystr));
+            "given \'%s\' object is not callable", cpyrt_PyText_AsString(pystr));
         Py_DECREF(pystr);
         return nullptr;
     }
@@ -819,8 +819,8 @@ static PyObject* AddTypeReducer(PyObject*, PyObject* args)
     if (!PyArg_ParseTuple(args, const_cast<char*>("ss"), &reducable, &reduced))
         return nullptr;
 
-    Cppyy::TCppType_t reducable_type = Cppyy::GetTypeFromScope(Cppyy::GetScope(reducable));
-    Cppyy::TCppType_t reduced_type = Cppyy::GetTypeFromScope(Cppyy::GetScope(reduced));
+    cppjit::interop::TCppType_t reducable_type = cppjit::interop::GetTypeFromScope(cppjit::interop::GetScope(reducable));
+    cppjit::interop::TCppType_t reduced_type = cppjit::interop::GetTypeFromScope(cppjit::interop::GetScope(reduced));
     TypeReductionMap[reducable_type] = reduced_type;
 
     Py_RETURN_NONE;
@@ -884,7 +884,7 @@ static PyObject* AddSmartPtrType(PyObject*, PyObject* args)
     if (!PyArg_ParseTuple(args, const_cast<char*>("s"), &type_name))
         return nullptr;
 
-    // Cppyy::AddSmartPtrType(type_name);
+    // cppjit::interop::AddSmartPtrType(type_name);
 
     Py_RETURN_NONE;
 }
@@ -916,15 +916,15 @@ static PyObject* EndCaptureStderr(PyObject*, PyObject*)
 
 
 //- data -----------------------------------------------------------------------
-static PyMethodDef gCPyCppyyMethods[] = {
-    {(char*) "CreateScopeProxy", (PyCFunction)CPyCppyy::CreateScopeProxy,
-      METH_VARARGS, (char*)"cppyy internal function"},
+static PyMethodDef gcpyrtMethods[] = {
+    {(char*) "CreateScopeProxy", (PyCFunction)cppjit::cpyrt::CreateScopeProxy,
+      METH_VARARGS, (char*)"cppjit internal function"},
     {(char*) "MakeCppTemplateClass", (PyCFunction)MakeCppTemplateClass,
-      METH_VARARGS, (char*)"cppyy internal function"},
+      METH_VARARGS, (char*)"cppjit internal function"},
     {(char*) "_set_cpp_lazy_lookup", (PyCFunction)SetCppLazyLookup,
-      METH_VARARGS, (char*)"cppyy internal function"},
-    {(char*) "_DestroyPyStrings", (PyCFunction)CPyCppyy::DestroyPyStrings,
-      METH_NOARGS, (char*)"cppyy internal function"},
+      METH_VARARGS, (char*)"cppjit internal function"},
+    {(char*) "_DestroyPyStrings", (PyCFunction)cppjit::cpyrt::DestroyPyStrings,
+      METH_NOARGS, (char*)"cppjit internal function"},
     {(char*) "addressof", (PyCFunction)addressof,
       METH_VARARGS | METH_KEYWORDS, (char*)"Retrieve address of proxied object or field as a value."},
     {(char*) "as_cobject", (PyCFunction)AsCObject,
@@ -969,13 +969,13 @@ struct module_state {
 
 #define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
 
-static int cpycppyymodule_traverse(PyObject* m, visitproc visit, void* arg)
+static int cpycppjitmodule_traverse(PyObject* m, visitproc visit, void* arg)
 {
     Py_VISIT(GETSTATE(m)->error);
     return 0;
 }
 
-static int cpycppyymodule_clear(PyObject* m)
+static int cpycppjitmodule_clear(PyObject* m)
 {
     Py_CLEAR(GETSTATE(m)->error);
     return 0;
@@ -984,25 +984,25 @@ static int cpycppyymodule_clear(PyObject* m)
 
 static struct PyModuleDef moduledef = {
     PyModuleDef_HEAD_INIT,
-    "libcppyy",
+    "libcppjit",
     nullptr,
     sizeof(struct module_state),
-    gCPyCppyyMethods,
+    gcpyrtMethods,
     nullptr,
-    cpycppyymodule_traverse,
-    cpycppyymodule_clear,
+    cpycppjitmodule_traverse,
+    cpycppjitmodule_clear,
     nullptr
 };
 
-namespace CPyCppyy {
+namespace cppjit::cpyrt {
 
 //----------------------------------------------------------------------------
-extern "C" PyObject* PyInit_libcppyy()
+extern "C" PyObject* PyInit_libcppjit()
 {
-// Initialization of extension module libcppyy.
+// Initialization of extension module libcppjit.
 
 // load commonly used python strings
-    if (!CPyCppyy::CreatePyStrings())
+    if (!cppjit::cpyrt::CreatePyStrings())
         return nullptr;
 
 // setup interpreter
@@ -1080,25 +1080,25 @@ extern "C" PyObject* PyInit_libcppyy()
         return nullptr;
 
 // inject identifiable nullptr and default
-    gNullPtrObject = (PyObject*)&_CPyCppyy_NullPtrStruct;
+    gNullPtrObject = (PyObject*)&_cpyrt_NullPtrStruct;
     Py_INCREF(gNullPtrObject);
     PyModule_AddObject(gThisModule, (char*)"nullptr", gNullPtrObject);
 
-    gDefaultObject = (PyObject*)&_CPyCppyy_DefaultStruct;
+    gDefaultObject = (PyObject*)&_cpyrt_DefaultStruct;
     Py_INCREF(gDefaultObject);
     PyModule_AddObject(gThisModule, (char*)"default", gDefaultObject);
 
 // C++-specific exceptions
-    PyObject* cppfatal = PyErr_NewException((char*)"cppyy.ll.FatalError", nullptr, nullptr);
+    PyObject* cppfatal = PyErr_NewException((char*)"cppjit.ll.FatalError", nullptr, nullptr);
     PyModule_AddObject(gThisModule, (char*)"FatalError", cppfatal);
 
-    gBusException  = PyErr_NewException((char*)"cppyy.ll.BusError", cppfatal, nullptr);
+    gBusException  = PyErr_NewException((char*)"cppjit.ll.BusError", cppfatal, nullptr);
     PyModule_AddObject(gThisModule, (char*)"BusError", gBusException);
-    gSegvException = PyErr_NewException((char*)"cppyy.ll.SegmentationViolation", cppfatal, nullptr);
+    gSegvException = PyErr_NewException((char*)"cppjit.ll.SegmentationViolation", cppfatal, nullptr);
     PyModule_AddObject(gThisModule, (char*)"SegmentationViolation", gSegvException);
-    gIllException  = PyErr_NewException((char*)"cppyy.ll.IllegalInstruction", cppfatal, nullptr);
+    gIllException  = PyErr_NewException((char*)"cppjit.ll.IllegalInstruction", cppfatal, nullptr);
     PyModule_AddObject(gThisModule, (char*)"IllegalInstruction", gIllException);
-    gAbrtException = PyErr_NewException((char*)"cppyy.ll.AbortSignal", cppfatal, nullptr);
+    gAbrtException = PyErr_NewException((char*)"cppjit.ll.AbortSignal", cppfatal, nullptr);
     PyModule_AddObject(gThisModule, (char*)"AbortSignal", gAbrtException);
 
 // policy labels
@@ -1107,7 +1107,7 @@ extern "C" PyObject* PyInit_libcppyy()
     PyModule_AddObject(gThisModule, (char*)"kMemoryStrict",
         PyInt_FromLong((int)CallContext::kUseStrict));
 
-// gbl namespace is injected in cppyy.py
+// gbl namespace is injected in cppjit.py
 
 // create the memory regulator
     static MemoryRegulator s_memory_regulator;
@@ -1116,4 +1116,4 @@ extern "C" PyObject* PyInit_libcppyy()
     return gThisModule;
 }
 
-} // namespace CPyCppyy
+} // namespace cppjit::cpyrt
diff --git a/test/conftest.py b/test/conftest.py
index d37cad4..068ab9a 100644
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -1,11 +1,36 @@
-"""alias cppyy to cppjit.cppyy so upstream tests work unmodified."""
+"""alias cppyy to cppjit so the upstream tests run unmodified."""
+import builtins
 import sys
 
 import cppjit
-import cppjit.cppyy
-import cppjit.cppyy_backend
+import cppjit_backend
 
-sys.modules['cppyy'] = cppjit.cppyy
-sys.modules['cppyy_backend'] = cppjit.cppyy_backend
+sys.modules['cppyy'] = cppjit
+sys.modules['cppyy_backend'] = cppjit_backend
+# pseudo-modules the frontend registers under its own name
+sys.modules['cppyy.gbl'] = sys.modules['cppjit.gbl']
+sys.modules['cppyy.gbl.std'] = sys.modules['cppjit.gbl.std']
+
+# 'from cppyy.gbl.<ns> import X': namespace proxies self-register in
+# sys.modules under their cppjit.* names when created (ProxyWrappers).
+# Mirror the registration under the requested cppyy.* spelling, forcing
+# proxy creation by attribute walk when needed.
+_orig_import = builtins.__import__
+
+def _alias_import(name, globals=None, locals=None, fromlist=(), level=0):
+    if level == 0 and name.startswith('cppyy.') and name not in sys.modules:
+        alt = 'cppjit' + name[5:]
+        if alt not in sys.modules:
+            try:
+                obj = cppjit
+                for part in alt.split('.')[1:]:
+                    obj = getattr(obj, part)
+            except AttributeError:
+                pass
+        if alt in sys.modules:
+            sys.modules[name] = sys.modules[alt]
+    return _orig_import(name, globals, locals, fromlist, level)
+
+builtins.__import__ = _alias_import
 
 disabled = None
diff --git a/test/pythonizables.cxx b/test/pythonizables.cxx
index 8729067..dc63071 100644
--- a/test/pythonizables.cxx
+++ b/test/pythonizables.cxx
@@ -69,7 +69,7 @@ static inline void replace_method_name(PyObject* klass, const char* n1, const ch
     PyObject_DelAttrString(klass, n1);
 }
 
-void pyzables::WithCallback1::WithCallback1::__cppyy_explicit_pythonize__(PyObject* klass, const std::string& name) {
+void pyzables::WithCallback1::WithCallback1::__cppjit_explicit_pythonize__(PyObject* klass, const std::string& name) {
 // change methods to camel case
     replace_method_name(klass, "get_int", "GetInt");
     replace_method_name(klass, "set_int", "SetInt");
@@ -85,7 +85,7 @@ pyzables::WithCallback2::WithCallback2(int i) : m_int(i) {}
 int pyzables::WithCallback2::get_int() { return m_int; }
 void pyzables::WithCallback2::set_int(int i) { m_int = i; }
 
-void pyzables::WithCallback2::WithCallback2::__cppyy_pythonize__(PyObject* klass, const std::string& name) {
+void pyzables::WithCallback2::WithCallback2::__cppjit_pythonize__(PyObject* klass, const std::string& name) {
 // change methods to camel case
     replace_method_name(klass, "get_int", "GetInt");
     replace_method_name(klass, "set_int", "SetInt");
diff --git a/test/pythonizables.h b/test/pythonizables.h
index 1dc5610..ac5a882 100644
--- a/test/pythonizables.h
+++ b/test/pythonizables.h
@@ -137,7 +137,7 @@ class WithCallback1 {
     int m_int;
 
 public:
-    static void __cppyy_explicit_pythonize__(PyObject* klass, const std::string&);
+    static void __cppjit_explicit_pythonize__(PyObject* klass, const std::string&);
     static std::string klass_name;
 };
 
@@ -153,7 +153,7 @@ class WithCallback2 {
     int m_int;
 
 public:
-    static void __cppyy_pythonize__(PyObject* klass, const std::string&);
+    static void __cppjit_pythonize__(PyObject* klass, const std::string&);
     static std::string klass_name;
 };
 
diff --git a/test/test_api.py b/test/test_api.py
index 586803a..73cb359 100644
--- a/test/test_api.py
+++ b/test/test_api.py
@@ -9,14 +9,14 @@ def setup_class(cls):
             skip('C++ API only available on CPython')
 
         import cppyy
-        cppyy.include('CPyCppyy/API.h')
+        cppyy.include('cpyrt/API.h')
 
     def test01_type_checking(self):
         """Python class type checks"""
 
         import cppyy
         cpp = cppyy.gbl
-        API = cpp.CPyCppyy
+        API = cpp.cppjit.cpyrt
 
         cppyy.cppdef("""
         class APICheck {
@@ -40,7 +40,7 @@ def test02_interpreter_access(self):
         """Access to the python interpreter"""
 
         import cppyy
-        API = cppyy.gbl.CPyCppyy
+        API = cppyy.gbl.cppjit.cpyrt
 
         assert API.Exec('import sys')
 
@@ -50,7 +50,7 @@ def test03_instance_conversion(self):
 
         import cppyy
         cpp = cppyy.gbl
-        API = cpp.CPyCppyy
+        API = cpp.cppjit.cpyrt
 
         cppyy.cppdef("""
         class APICheck2 {
@@ -71,7 +71,7 @@ def test04_custom_converter(self):
         import cppyy
 
         cppyy.cppdef("""
-        #include "CPyCppyy/API.h"
+        #include "cpyrt/API.h"
 
         class APICheck3 {
             int fFlags;
@@ -87,10 +87,10 @@ class APICheck3 {
             bool wasToMemoryCalled()   { return fFlags & 0x04; }
         };
 
-        class APICheck3Converter : public CPyCppyy::Converter {
+        class APICheck3Converter : public cppjit::cpyrt::Converter {
         public:
-            virtual bool SetArg(PyObject* pyobject, CPyCppyy::Parameter& para, CPyCppyy::CallContext* = nullptr) {
-                APICheck3* a3 = (APICheck3*)CPyCppyy::Instance_AsVoidPtr(pyobject);
+            virtual bool SetArg(PyObject* pyobject, cppjit::cpyrt::Parameter& para, cppjit::cpyrt::CallContext* = nullptr) {
+                APICheck3* a3 = (APICheck3*)cppjit::cpyrt::Instance_AsVoidPtr(pyobject);
                 a3->setSetArgCalled();
                 para.fValue.fVoidp = a3;
                 para.fTypeCode = 'V';
@@ -100,25 +100,25 @@ class APICheck3Converter : public CPyCppyy::Converter {
             virtual PyObject* FromMemory(void* address) {
                 APICheck3* a3 = (APICheck3*)address;
                 a3->setFromMemoryCalled();
-                return CPyCppyy::Instance_FromVoidPtr(a3, "APICheck3");
+                return cppjit::cpyrt::Instance_FromVoidPtr(a3, "APICheck3");
             }
 
             virtual bool ToMemory(PyObject* value, void* address) {
                 APICheck3* a3 = (APICheck3*)address;
                 a3->setToMemoryCalled();
-                *a3 = *(APICheck3*)CPyCppyy::Instance_AsVoidPtr(value);
+                *a3 = *(APICheck3*)cppjit::cpyrt::Instance_AsVoidPtr(value);
                 return true;
             }
         };
 
-        typedef CPyCppyy::ConverterFactory_t cf_t;
+        typedef cppjit::cpyrt::ConverterFactory_t cf_t;
         void register_a3() {
-            CPyCppyy::RegisterConverter("APICheck3",  (cf_t)+[](CPyCppyy::cdims_t) { static APICheck3Converter c{}; return &c; });
-            CPyCppyy::RegisterConverter("APICheck3&", (cf_t)+[](CPyCppyy::cdims_t) { static APICheck3Converter c{}; return &c; });
+            cppjit::cpyrt::RegisterConverter("APICheck3",  (cf_t)+[](cppjit::cpyrt::cdims_t) { static APICheck3Converter c{}; return &c; });
+            cppjit::cpyrt::RegisterConverter("APICheck3&", (cf_t)+[](cppjit::cpyrt::cdims_t) { static APICheck3Converter c{}; return &c; });
         }
         void unregister_a3() {
-            CPyCppyy::UnregisterConverter("APICheck3");
-            CPyCppyy::UnregisterConverter("APICheck3&");
+            cppjit::cpyrt::UnregisterConverter("APICheck3");
+            cppjit::cpyrt::UnregisterConverter("APICheck3&");
         }
 
         APICheck3 gA3a, gA3b;
@@ -150,7 +150,7 @@ def test05_custom_executor(self):
         import cppyy
 
         cppyy.cppdef("""
-        #include "CPyCppyy/API.h"
+        #include "cpyrt/API.h"
 
         class APICheck4 {
             int fFlags;
@@ -162,21 +162,21 @@ class APICheck4 {
             bool wasExecutorCalled() { return fFlags & 0x01; }
         };
 
-        class APICheck4Executor : public CPyCppyy::Executor {
+        class APICheck4Executor : public cppjit::cpyrt::Executor {
         public:
-             virtual PyObject* Execute(Cppyy::TCppMethod_t meth, Cppyy::TCppObject_t obj, CPyCppyy::CallContext* ctxt) {
-                 APICheck4* a4 = (APICheck4*)CPyCppyy::CallVoidP(meth, obj, ctxt);
+             virtual PyObject* Execute(cppjit::interop::TCppMethod_t meth, cppjit::interop::TCppObject_t obj, cppjit::cpyrt::CallContext* ctxt) {
+                 APICheck4* a4 = (APICheck4*)cppjit::cpyrt::CallVoidP(meth, obj, ctxt);
                  a4->setExecutorCalled();
-                 return CPyCppyy::Instance_FromVoidPtr(a4, "APICheck4", true);
+                 return cppjit::cpyrt::Instance_FromVoidPtr(a4, "APICheck4", true);
              }
         };
 
-        typedef CPyCppyy::ExecutorFactory_t ef_t;
+        typedef cppjit::cpyrt::ExecutorFactory_t ef_t;
         void register_a4() {
-            CPyCppyy::RegisterExecutor("APICheck4*", (ef_t)+[](CPyCppyy::cdims_t) { static APICheck4Executor c{}; return &c; });
+            cppjit::cpyrt::RegisterExecutor("APICheck4*", (ef_t)+[](cppjit::cpyrt::cdims_t) { static APICheck4Executor c{}; return &c; });
         }
         void unregister_a4() {
-            CPyCppyy::UnregisterExecutor("APICheck4*");
+            cppjit::cpyrt::UnregisterExecutor("APICheck4*");
         }
 
         APICheck4* CreateAPICheck4() { return new APICheck4{}; }
@@ -204,7 +204,7 @@ def test06_custom_executor(self):
         import cppyy
 
         cppyy.cppdef("""
-        #include "CPyCppyy/API.h"
+        #include "cpyrt/API.h"
 
         namespace ArrayLike {
         class MyClass{};
@@ -217,7 +217,7 @@ class MyArray {
         }; }""")
 
         ns = cppyy.gbl.ArrayLike;
-        Sequence_Check = cppyy.gbl.CPyCppyy.Sequence_Check
+        Sequence_Check = cppyy.gbl.cppjit.cpyrt.Sequence_Check
 
         assert not Sequence_Check(ns.my)
         assert     Sequence_Check(ns.myA)
diff --git a/test/test_concurrent.py b/test/test_concurrent.py
index 2d5fc7c..bc7dff3 100644
--- a/test/test_concurrent.py
+++ b/test/test_concurrent.py
@@ -95,7 +95,7 @@ def test04_cpp_threading_with_exceptions(self):
 
         import cppyy
 
-        cppyy.include("CPyCppyy/PyException.h")
+        cppyy.include("cpyrt/PyException.h")
 
         cppyy.cppdef("""
         #include <thread>
@@ -116,7 +116,7 @@ def test04_cpp_threading_with_exceptions(self):
                     while (counter++ < 10)
                         try {
                             cons->process(counter);
-                        } catch (CPyCppyy::PyException& e) {
+                        } catch (cppjit::cpyrt::PyException& e) {
                             err_msg = e.what();
                             return;
                         }
diff --git a/test/test_crossinheritance.py b/test/test_crossinheritance.py
index 748ce1a..1b1ac3d 100644
--- a/test/test_crossinheritance.py
+++ b/test/test_crossinheritance.py
@@ -266,7 +266,7 @@ def sum_value(self, val):
         std::string call_base1(Base1* b) {
             try {
                 b->sum_value(-7);
-            } catch (CPyCppyy::PyException& e) {
+            } catch (cppjit::cpyrt::PyException& e) {
                 e.clear();
                 return e.what();
             }
diff --git a/test/test_doc_features.py b/test/test_doc_features.py
index b77d03a..e030368 100644
--- a/test/test_doc_features.py
+++ b/test/test_doc_features.py
@@ -207,7 +207,7 @@ def test_classes_and_structs(self):
         n = Namespace.Concrete.NestedClass()
         assert 'Namespace.Concrete.NestedClass' in str(type(n))
         assert 'NestedClass' == type(n).__name__
-        assert 'cppyy.gbl.Namespace.Concrete' == type(n).__module__
+        assert 'cppjit.gbl.Namespace.Concrete' == type(n).__module__
         assert 'Namespace::Concrete::NestedClass' == type(n).__cpp_name__
 
     def test_data_members(self):
diff --git a/test/test_fragile.py b/test/test_fragile.py
index 5c39c51..5e3ed79 100644
--- a/test/test_fragile.py
+++ b/test/test_fragile.py
@@ -246,7 +246,7 @@ def test11_dir(self):
         struct DeclRef;
         }  // namespace Cpp
 
-        namespace Cppyy {
+        namespace cppjit::interop {
         typedef Cpp::DeclRef TCppScope_t;
 
         CPPYY_IMPORT TCppScope_t GetScope(const std::string& scope_name, TCppScope_t parent_scope = TCppScope_t());
@@ -267,11 +267,11 @@ def test11_dir(self):
 
         assert 'S' in dir(cppyy.gbl.GG)
 
-        handle = cppyy.gbl.Cppyy.GetScope("GG::S")
+        handle = cppyy.gbl.cppjit.interop.GetScope("GG::S")
         assert handle
 
         cppnames = cppyy.gbl.std.set[str]()
-        cppyy.gbl.Cppyy.GetAllCppNames(handle, cppnames)
+        cppyy.gbl.cppjit.interop.GetAllCppNames(handle, cppnames)
 
         assert 'S' in cppnames
         assert '_a' in cppnames
@@ -311,33 +311,33 @@ def fail_import():
         from cppyy.gbl.fragile import nested1
         assert cppyy.gbl.fragile.nested1 is nested1
         assert nested1.__name__ == 'nested1'
-        assert nested1.__module__ == 'cppyy.gbl.fragile'
+        assert nested1.__module__ == 'cppjit.gbl.fragile'
         assert nested1.__cpp_name__ == 'fragile::nested1'
 
         from cppyy.gbl.fragile.nested1 import A, nested2
         assert cppyy.gbl.fragile.nested1.A is A
         assert A.__name__ == 'A'
-        assert A.__module__ == 'cppyy.gbl.fragile.nested1'
+        assert A.__module__ == 'cppjit.gbl.fragile.nested1'
         assert A.__cpp_name__ == 'fragile::nested1::A'
         assert cppyy.gbl.fragile.nested1.nested2 is nested2
         assert nested2.__name__ == 'nested2'
-        assert nested2.__module__ == 'cppyy.gbl.fragile.nested1'
+        assert nested2.__module__ == 'cppjit.gbl.fragile.nested1'
         assert nested2.__cpp_name__ == 'fragile::nested1::nested2'
 
         from cppyy.gbl.fragile.nested1.nested2 import A, nested3
         assert cppyy.gbl.fragile.nested1.nested2.A is A
         assert A.__name__ == 'A'
-        assert A.__module__ == 'cppyy.gbl.fragile.nested1.nested2'
+        assert A.__module__ == 'cppjit.gbl.fragile.nested1.nested2'
         assert A.__cpp_name__ == 'fragile::nested1::nested2::A'
         assert cppyy.gbl.fragile.nested1.nested2.nested3 is nested3
         assert nested3.__name__ == 'nested3'
-        assert nested3.__module__ == 'cppyy.gbl.fragile.nested1.nested2'
+        assert nested3.__module__ == 'cppjit.gbl.fragile.nested1.nested2'
         assert nested3.__cpp_name__ == 'fragile::nested1::nested2::nested3'
 
         from cppyy.gbl.fragile.nested1.nested2.nested3 import A
         assert cppyy.gbl.fragile.nested1.nested2.nested3.A is nested3.A
         assert A.__name__ == 'A'
-        assert A.__module__ == 'cppyy.gbl.fragile.nested1.nested2.nested3'
+        assert A.__module__ == 'cppjit.gbl.fragile.nested1.nested2.nested3'
         assert A.__cpp_name__ == 'fragile::nested1::nested2::nested3::A'
 
         # test writability of __module__
@@ -645,11 +645,11 @@ def test27_pickle_enums(self):
         }""")
 
         e1 = cppyy.gbl.MyPickleEnum
-        assert e1.__module__ == 'cppyy.gbl'
+        assert e1.__module__ == 'cppjit.gbl'
         assert pickle.dumps(e1.PickleFoo)
 
         e2 = cppyy.gbl.MyPickleNamespace.MyPickleEnum
-        assert e2.__module__ == 'cppyy.gbl.MyPickleNamespace'
+        assert e2.__module__ == 'cppjit.gbl.MyPickleNamespace'
         assert pickle.dumps(e2.PickleBar)
 
     def test28_memoryview_of_empty(self):
diff --git a/test/test_regression.py b/test/test_regression.py
index 942807c..aecb290 100644
--- a/test/test_regression.py
+++ b/test/test_regression.py
@@ -1375,15 +1375,15 @@ def test45_typedef_resolution(self):
         import cppyy
 
         cppyy.cppdef("""\
-        namespace Cppyy {
+        namespace cppjit::interop {
             std::string ResolveName(const std::string& name);
         }
         typedef const int my_custom_type_t;
         typedef const int cmy_custom_type_t;
         """)
 
-        assert cppyy.gbl.Cppyy.ResolveName("my_custom_type_t") == "const int"
-        assert cppyy.gbl.Cppyy.ResolveName("cmy_custom_type_t") == "const int"
+        assert cppyy.gbl.cppjit.interop.ResolveName("my_custom_type_t") == "const int"
+        assert cppyy.gbl.cppjit.interop.ResolveName("cmy_custom_type_t") == "const int"
 
     @mark.xfail(run=False, condition=IS_MAC_ARM, reason="Crashes with exception not being caught on Apple Silicon")
     def test46_exception_narrowing(self):
diff --git a/test/test_stltypes.py b/test/test_stltypes.py
index 8cfd5cf..fb42ce0 100644
--- a/test/test_stltypes.py
+++ b/test/test_stltypes.py
@@ -2050,14 +2050,14 @@ def test01_basics(self):
         assert issubclass(MyError, cppyy.gbl.std.exception)
         assert MyError.__name__     == 'MyError'
         assert MyError.__cpp_name__ == 'MyError'
-        assert MyError.__module__   == 'cppyy.gbl'
+        assert MyError.__module__   == 'cppjit.gbl'
 
         YourError = cppyy.gbl.YourError
         assert YourError is cppyy.gbl.YourError
         assert issubclass(YourError, MyError)
         assert YourError.__name__     == 'YourError'
         assert YourError.__cpp_name__ == 'YourError'
-        assert YourError.__module__   == 'cppyy.gbl'
+        assert YourError.__module__   == 'cppjit.gbl'
 
         MyError = cppyy.gbl.ErrorNamespace.MyError
         assert MyError is not cppyy.gbl.MyError
@@ -2066,7 +2066,7 @@ def test01_basics(self):
         assert issubclass(MyError, cppyy.gbl.std.exception)
         assert MyError.__name__     == 'MyError'
         assert MyError.__cpp_name__ == 'ErrorNamespace::MyError'
-        assert MyError.__module__   == 'cppyy.gbl.ErrorNamespace'
+        assert MyError.__module__   == 'cppjit.gbl.ErrorNamespace'
 
         YourError = cppyy.gbl.ErrorNamespace.YourError
         assert YourError is not cppyy.gbl.YourError
@@ -2074,7 +2074,7 @@ def test01_basics(self):
         assert issubclass(YourError, MyError)
         assert YourError.__name__     == 'YourError'
         assert YourError.__cpp_name__ == 'ErrorNamespace::YourError'
-        assert YourError.__module__   == 'cppyy.gbl.ErrorNamespace'
+        assert YourError.__module__   == 'cppjit.gbl.ErrorNamespace'
 
     @mark.xfail(condition=IS_MAC, reason="Fails on OS X")
     def test02_raising(self):