diff --git a/.cudaq_version b/.cudaq_version
index 1b8bb6b8..fb1402ab 100644
--- a/.cudaq_version
+++ b/.cudaq_version
@@ -1,6 +1,6 @@
 {
   "cudaq": {
     "repository": "NVIDIA/cuda-quantum",
-    "ref": "5b1000af08ad059c82af94f18782f06e0ecd12d3"
+    "ref": "887759d8152894b9ae4851d790724938eafdd149"
   }
 }
diff --git a/libs/core/include/cuda-qx/core/extension_point.h b/libs/core/include/cuda-qx/core/extension_point.h
deleted file mode 100644
index fec2d4b5..00000000
--- a/libs/core/include/cuda-qx/core/extension_point.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/****************************************************************-*- C++ -*-****
- * Copyright (c) 2024 NVIDIA Corporation & Affiliates.                         *
- * All rights reserved.                                                        *
- *                                                                             *
- * This source code and the accompanying materials are made available under    *
- * the terms of the Apache License 2.0 which accompanies this distribution.    *
- ******************************************************************************/
-
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <stdexcept>
-#include <unordered_map>
-
-namespace cudaqx {
-
-/// @brief A template class for implementing an extension point mechanism.
-///
-/// This class provides a framework for registering and retrieving plugin-like
-/// extensions. It allows dynamic creation of objects based on registered types.
-///
-/// @tparam T The base type of the extensions.
-/// @tparam CtorArgs Variadic template parameters for constructor arguments.
-///
-/// How to use the extension_point class
-///
-/// The extension_point class provides a mechanism for creating extensible
-/// frameworks with plugin-like functionality. Here's how to use it:
-///
-/// 1. Define your extension point:
-///    Create a new class that inherits from cudaq::extension_point<YourClass>.
-///    This class should declare pure virtual methods that extensions will
-///    implement.
-///
-/// @code
-/// class MyExtensionPoint : public cudaq::extension_point<MyExtensionPoint> {
-/// public:
-///   virtual std::string parrotBack(const std::string &msg) const = 0;
-/// };
-/// @endcode
-///
-/// 2. Implement concrete extensions:
-///    Create classes that inherit from your extension point and implement its
-///    methods. Use the CUDAQ_EXTENSION_CREATOR_FUNCTION macro to define a
-///    creator function.
-///
-/// @code
-/// class RepeatBackOne : public MyExtensionPoint {
-/// public:
-///   std::string parrotBack(const std::string &msg) const override {
-///     return msg + " from RepeatBackOne.";
-///   }
-///
-///   CUDAQ_EXTENSION_CREATOR_FUNCTION(MyExtensionPoint, RepeatBackOne)
-/// };
-/// @endcode
-///
-/// 3. Register your extensions:
-///    Use the CUDAQ_REGISTER_TYPE macro to register each extension.
-///
-/// @code
-/// CUDAQ_REGISTER_TYPE(RepeatBackOne)
-/// @endcode
-///
-/// 4. Use your extensions:
-///    You can now create instances of your extensions, check registrations, and
-///    more.
-///
-/// @code
-/// auto extension = MyExtensionPoint::get("RepeatBackOne");
-/// std::cout << extension->parrotBack("Hello") << std::endl;
-///
-/// auto registeredTypes = MyExtensionPoint::get_registered();
-/// bool isRegistered = MyExtensionPoint::is_registered("RepeatBackOne");
-/// @endcode
-///
-/// This approach allows for a flexible, extensible design where new
-/// functionality can be added without modifying existing code.
-template <typename T, typename... CtorArgs>
-class extension_point {
-
-  /// Type alias for the creator function.
-  using CreatorFunction = std::function<std::unique_ptr<T>(CtorArgs...)>;
-
-protected:
-  /// @brief Get the registry of creator functions.
-  /// @return A reference to the static registry map.
-  /// See INSTANTIATE_REGISTRY() macros below for sample implementations that
-  /// need to be included in C++ source files.
-  static std::unordered_map<std::string, CreatorFunction> &get_registry();
-
-public:
-  /// @brief Create an instance of a registered extension.
-  /// @param name The identifier of the registered extension.
-  /// @param args Constructor arguments for the extension.
-  /// @return A unique pointer to the created instance.
-  /// @throws std::runtime_error if the extension is not found.
-  static std::unique_ptr<T> get(const std::string &name, CtorArgs... args) {
-    auto &registry = get_registry();
-    auto iter = registry.find(name);
-    if (iter == registry.end())
-      throw std::runtime_error("Cannot find extension with name = " + name);
-
-    return iter->second(std::forward<CtorArgs>(args)...);
-  }
-
-  /// @brief Get a list of all registered extension names.
-  /// @return A vector of registered extension names.
-  static std::vector<std::string> get_registered() {
-    std::vector<std::string> names;
-    auto &registry = get_registry();
-    for (auto &[k, v] : registry)
-      names.push_back(k);
-    return names;
-  }
-
-  /// @brief Check if an extension is registered.
-  /// @param name The identifier of the extension to check.
-  /// @return True if the extension is registered, false otherwise.
-  static bool is_registered(const std::string &name) {
-    auto &registry = get_registry();
-    return registry.find(name) != registry.end();
-  }
-};
-
-/// @brief Macro for defining a creator function for an extension.
-/// @param BASE The base class of the extension.
-/// @param TYPE The derived class implementing the extension.
-#define CUDAQ_EXTENSION_CREATOR_FUNCTION(BASE, TYPE)                           \
-  static inline bool register_type() {                                         \
-    auto &registry = get_registry();                                           \
-    registry[TYPE::class_identifier] = TYPE::create;                           \
-    return true;                                                               \
-  }                                                                            \
-  static const bool registered_;                                               \
-  static inline const std::string class_identifier = #TYPE;                    \
-  static std::unique_ptr<BASE> create() { return std::make_unique<TYPE>(); }
-
-/// @brief Macro for defining a custom creator function for an extension.
-/// @param TYPE The class implementing the extension.
-/// @param ... Custom implementation of the create function.
-#define CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(TYPE, ...)                     \
-  static inline bool register_type() {                                         \
-    auto &registry = get_registry();                                           \
-    registry[TYPE::class_identifier] = TYPE::create;                           \
-    return true;                                                               \
-  }                                                                            \
-  static const bool registered_;                                               \
-  static inline const std::string class_identifier = #TYPE;                    \
-  __VA_ARGS__
-
-#define CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION_WITH_NAME(TYPE, NAME, ...)     \
-  static inline bool register_type() {                                         \
-    auto &registry = TYPE::get_registry();                                     \
-    registry.insert({NAME, TYPE::create});                                     \
-    return true;                                                               \
-  }                                                                            \
-  static const bool registered_;                                               \
-  static inline const std::string class_identifier = #TYPE;                    \
-  __VA_ARGS__
-
-/// @brief Macro for registering an extension type.
-/// @param TYPE The class to be registered as an extension.
-#define CUDAQ_REGISTER_TYPE(TYPE)                                              \
-  const bool TYPE::registered_ = TYPE::register_type();
-
-/// In order to support building CUDA-QX libraries with g++ and building
-/// application code with nvq++ (which uses clang++ under the hood), you must
-/// implement the templated get_registry() function for every set of
-/// extension_point<Args..>. This *must* be done in a C++ file that is built
-/// with the CUDA-QX libraries.
-///
-/// Use this version of the helper macro if the only template argument to
-/// extension_point<> is the derived class (with no additional creator args).
-#define INSTANTIATE_REGISTRY_NO_ARGS(FULL_TYPE_NAME)                           \
-  template <>                                                                  \
-  std::unordered_map<std::string,                                              \
-                     std::function<std::unique_ptr<FULL_TYPE_NAME>()>> &       \
-  cudaqx::extension_point<FULL_TYPE_NAME>::get_registry() {                    \
-    static std::unordered_map<                                                 \
-        std::string, std::function<std::unique_ptr<FULL_TYPE_NAME>()>>         \
-        registry;                                                              \
-    return registry;                                                           \
-  }
-
-/// Use this variadic version of the helper macro if there are additional
-/// arguments for the creator function.
-#define INSTANTIATE_REGISTRY(FULL_TYPE_NAME, ...)                              \
-  template <>                                                                  \
-  std::unordered_map<                                                          \
-      std::string,                                                             \
-      std::function<std::unique_ptr<FULL_TYPE_NAME>(__VA_ARGS__)>> &           \
-  cudaqx::extension_point<FULL_TYPE_NAME, __VA_ARGS__>::get_registry() {       \
-    static std::unordered_map<                                                 \
-        std::string,                                                           \
-        std::function<std::unique_ptr<FULL_TYPE_NAME>(__VA_ARGS__)>>           \
-        registry;                                                              \
-    return registry;                                                           \
-  }
-
-} // namespace cudaqx
diff --git a/libs/core/include/cuda-qx/core/tensor.h b/libs/core/include/cuda-qx/core/tensor.h
index ad309577..f0064e07 100644
--- a/libs/core/include/cuda-qx/core/tensor.h
+++ b/libs/core/include/cuda-qx/core/tensor.h
@@ -7,7 +7,6 @@
  ******************************************************************************/
 #pragma once
 
-#include "extension_point.h"
 #include "tensor_impl.h"
 #include "type_traits.h"
 
diff --git a/libs/core/include/cuda-qx/core/tensor_impl.h b/libs/core/include/cuda-qx/core/tensor_impl.h
index ea4cd16a..26ff3b4b 100644
--- a/libs/core/include/cuda-qx/core/tensor_impl.h
+++ b/libs/core/include/cuda-qx/core/tensor_impl.h
@@ -7,26 +7,27 @@
  ******************************************************************************/
 #pragma once
 
-#include "extension_point.h"
+#include "cudaq/utils/extension_point.h"
 
 #include <complex>
 #include <iostream>
 #include <memory>
 #include <numeric>
 #include <vector>
+
 namespace cudaqx::details {
 
 /// @brief Implementation class for tensor operations following the PIMPL idiom
 template <typename Scalar = std::complex<double>>
 class tensor_impl
-    : public cudaqx::extension_point<tensor_impl<Scalar>, const Scalar *,
-                                     const std::vector<std::size_t>> {
+    : public cudaq::extension_point<tensor_impl<Scalar>, const Scalar *,
+                                    const std::vector<std::size_t>> {
 public:
   /// @brief Type alias for the scalar type used in the tensor
   using scalar_type = Scalar;
   using BaseExtensionPoint =
-      cudaqx::extension_point<tensor_impl<Scalar>, const Scalar *,
-                              const std::vector<std::size_t>>;
+      cudaq::extension_point<tensor_impl<Scalar>, const Scalar *,
+                             const std::vector<std::size_t>>;
 
   /// @brief Create a tensor implementation with the given name and shape
   /// @param name The name of the tensor implementation
diff --git a/libs/core/lib/CMakeLists.txt b/libs/core/lib/CMakeLists.txt
index ae2ea875..c27f135e 100644
--- a/libs/core/lib/CMakeLists.txt
+++ b/libs/core/lib/CMakeLists.txt
@@ -19,6 +19,8 @@ target_include_directories(cudaqx-core
 )
 
 target_link_libraries(cudaqx-core
+  PUBLIC     
+    cudaq::cudaq
   PRIVATE
     xtensor
     xtensor-blas
diff --git a/libs/core/lib/tensor_impls/xtensor_impl.cpp b/libs/core/lib/tensor_impls/xtensor_impl.cpp
index e6a27293..bb991c67 100644
--- a/libs/core/lib/tensor_impls/xtensor_impl.cpp
+++ b/libs/core/lib/tensor_impls/xtensor_impl.cpp
@@ -296,7 +296,7 @@ class xtensor : public cudaqx::details::tensor_impl<Scalar> {
   /// @param d Pointer to the tensor data
   /// @param s Shape of the tensor
   /// @return A unique pointer to the created xtensor object
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION_WITH_NAME(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION_WITH_NAME(
       xtensor<Scalar>, std::string("xtensor") + std::string(ScalarAsString),
       static std::unique_ptr<cudaqx::details::tensor_impl<Scalar>> create(
           const Scalar *d, const std::vector<std::size_t> s) {
@@ -310,11 +310,13 @@ class xtensor : public cudaqx::details::tensor_impl<Scalar> {
   }
 };
 
+} // namespace cudaqx
+
 /// @brief Register the xtensor types
 
 #define INSTANTIATE_REGISTRY_TENSOR_IMPL(TYPE)                                 \
-  INSTANTIATE_REGISTRY(cudaqx::details::tensor_impl<TYPE>, const TYPE *,       \
-                       const std::vector<std::size_t>)
+  CUDAQ_INSTANTIATE_REGISTRY(cudaqx::details::tensor_impl<TYPE>, const TYPE *, \
+                             const std::vector<std::size_t>)
 
 INSTANTIATE_REGISTRY_TENSOR_IMPL(std::complex<double>)
 INSTANTIATE_REGISTRY_TENSOR_IMPL(std::complex<float>)
@@ -324,6 +326,7 @@ INSTANTIATE_REGISTRY_TENSOR_IMPL(double)
 INSTANTIATE_REGISTRY_TENSOR_IMPL(float)
 INSTANTIATE_REGISTRY_TENSOR_IMPL(std::size_t)
 
+namespace cudaqx {
 template <>
 const bool xtensor<std::complex<double>>::registered_ =
     xtensor<std::complex<double>>::register_type();
diff --git a/libs/core/unittests/test_core.cpp b/libs/core/unittests/test_core.cpp
index d4e8616d..2356d333 100644
--- a/libs/core/unittests/test_core.cpp
+++ b/libs/core/unittests/test_core.cpp
@@ -5,7 +5,6 @@
  * This source code and the accompanying materials are made available under    *
  * the terms of the Apache License 2.0 which accompanies this distribution.    *
  ******************************************************************************/
-#include "cuda-qx/core/extension_point.h"
 #include "cuda-qx/core/graph.h"
 #include "cuda-qx/core/heterogeneous_map.h"
 #include "cuda-qx/core/tensor.h"
@@ -15,153 +14,6 @@
 
 #include <gtest/gtest.h>
 
-namespace cudaqx::testing {
-
-// Define a new extension point for the framework
-class MyExtensionPoint : public cudaqx::extension_point<MyExtensionPoint> {
-public:
-  virtual std::string parrotBack(const std::string &msg) const = 0;
-  virtual ~MyExtensionPoint() = default;
-};
-
-} // namespace cudaqx::testing
-
-INSTANTIATE_REGISTRY_NO_ARGS(cudaqx::testing::MyExtensionPoint)
-
-namespace cudaqx::testing {
-
-// Define a concrete realization of that extension point
-class RepeatBackOne : public MyExtensionPoint {
-public:
-  std::string parrotBack(const std::string &msg) const override {
-    return msg + " from RepeatBackOne.";
-  }
-
-  // Extension must provide a creator function
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(MyExtensionPoint, RepeatBackOne)
-};
-
-// Extensions must register themselves
-CUDAQ_REGISTER_TYPE(RepeatBackOne)
-
-class RepeatBackTwo : public MyExtensionPoint {
-public:
-  std::string parrotBack(const std::string &msg) const override {
-    return msg + " from RepeatBackTwo.";
-  }
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(MyExtensionPoint, RepeatBackTwo)
-};
-CUDAQ_REGISTER_TYPE(RepeatBackTwo)
-
-} // namespace cudaqx::testing
-
-TEST(CoreTester, checkSimpleExtensionPoint) {
-
-  auto registeredNames = cudaqx::testing::MyExtensionPoint::get_registered();
-  EXPECT_EQ(registeredNames.size(), 2);
-  EXPECT_TRUE(std::find(registeredNames.begin(), registeredNames.end(),
-                        "RepeatBackTwo") != registeredNames.end());
-  EXPECT_TRUE(std::find(registeredNames.begin(), registeredNames.end(),
-                        "RepeatBackOne") != registeredNames.end());
-  EXPECT_TRUE(std::find(registeredNames.begin(), registeredNames.end(),
-                        "RepeatBackThree") == registeredNames.end());
-
-  {
-    auto var = cudaqx::testing::MyExtensionPoint::get("RepeatBackOne");
-    EXPECT_EQ(var->parrotBack("Hello World"),
-              "Hello World from RepeatBackOne.");
-  }
-  {
-    auto var = cudaqx::testing::MyExtensionPoint::get("RepeatBackTwo");
-    EXPECT_EQ(var->parrotBack("Hello World"),
-              "Hello World from RepeatBackTwo.");
-  }
-}
-
-namespace cudaqx::testing {
-
-class MyExtensionPointWithArgs
-    : public cudaqx::extension_point<MyExtensionPointWithArgs, int, double> {
-protected:
-  int i;
-  double d;
-
-public:
-  MyExtensionPointWithArgs(int i, double d) : i(i), d(d) {}
-  virtual std::tuple<int, double, std::string> parrotBack() const = 0;
-  virtual ~MyExtensionPointWithArgs() = default;
-};
-
-} // namespace cudaqx::testing
-
-INSTANTIATE_REGISTRY(cudaqx::testing::MyExtensionPointWithArgs, int, double)
-
-namespace cudaqx::testing {
-
-class RepeatBackOneWithArgs : public MyExtensionPointWithArgs {
-public:
-  using MyExtensionPointWithArgs::MyExtensionPointWithArgs;
-  std::tuple<int, double, std::string> parrotBack() const override {
-    return std::make_tuple(i, d, "RepeatBackOne");
-  }
-
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
-      RepeatBackOneWithArgs,
-      static std::unique_ptr<MyExtensionPointWithArgs> create(int i, double d) {
-        return std::make_unique<RepeatBackOneWithArgs>(i, d);
-      })
-};
-
-CUDAQ_REGISTER_TYPE(RepeatBackOneWithArgs)
-
-class RepeatBackTwoWithArgs : public MyExtensionPointWithArgs {
-public:
-  using MyExtensionPointWithArgs::MyExtensionPointWithArgs;
-  std::tuple<int, double, std::string> parrotBack() const override {
-    return std::make_tuple(i, d, "RepeatBackTwo");
-  }
-
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
-      RepeatBackTwoWithArgs,
-      static std::unique_ptr<MyExtensionPointWithArgs> create(int i, double d) {
-        return std::make_unique<RepeatBackTwoWithArgs>(i, d);
-      })
-};
-
-CUDAQ_REGISTER_TYPE(RepeatBackTwoWithArgs)
-
-} // namespace cudaqx::testing
-
-TEST(CoreTester, checkSimpleExtensionPointWithArgs) {
-
-  auto registeredNames =
-      cudaqx::testing::MyExtensionPointWithArgs::get_registered();
-  EXPECT_EQ(registeredNames.size(), 2);
-  EXPECT_TRUE(std::find(registeredNames.begin(), registeredNames.end(),
-                        "RepeatBackTwoWithArgs") != registeredNames.end());
-  EXPECT_TRUE(std::find(registeredNames.begin(), registeredNames.end(),
-                        "RepeatBackOneWithArgs") != registeredNames.end());
-  EXPECT_TRUE(std::find(registeredNames.begin(), registeredNames.end(),
-                        "RepeatBackThree") == registeredNames.end());
-
-  {
-    auto var = cudaqx::testing::MyExtensionPointWithArgs::get(
-        "RepeatBackOneWithArgs", 5, 2.2);
-    auto [i, d, msg] = var->parrotBack();
-    EXPECT_EQ(msg, "RepeatBackOne");
-    EXPECT_EQ(i, 5);
-    EXPECT_NEAR(d, 2.2, 1e-2);
-  }
-  {
-    auto var = cudaqx::testing::MyExtensionPointWithArgs::get(
-        "RepeatBackTwoWithArgs", 15, 12.2);
-    auto [i, d, msg] = var->parrotBack();
-    EXPECT_EQ(msg, "RepeatBackTwo");
-    EXPECT_EQ(i, 15);
-    EXPECT_NEAR(d, 12.2, 1e-2);
-  }
-}
-
 TEST(CoreTester, checkTensorSimple) {
   auto registeredNames = cudaqx::details::tensor_impl<>::get_registered();
   EXPECT_EQ(registeredNames.size(), 1);
diff --git a/libs/qec/include/cudaq/qec/code.h b/libs/qec/include/cudaq/qec/code.h
index cf4a2486..94d1a902 100644
--- a/libs/qec/include/cudaq/qec/code.h
+++ b/libs/qec/include/cudaq/qec/code.h
@@ -16,9 +16,9 @@
 #include "cudaq/qec/patch.h"
 #include "cudaq/qec/stabilizer_utils.h"
 
-#include "cuda-qx/core/extension_point.h"
 #include "cuda-qx/core/heterogeneous_map.h"
 #include "cuda-qx/core/tensor.h"
+#include "cudaq/utils/extension_point.h"
 
 using namespace cudaqx;
 
@@ -95,7 +95,7 @@ enum class operation {
 /// CUDAQ_REGISTER_TYPE(my_code)
 /// @endcode
 /// @brief Supported quantum operations for error correcting codes
-class code : public cudaqx::extension_point<code, const heterogeneous_map &> {
+class code : public cudaq::extension_point<code, const heterogeneous_map &> {
 public:
   /// @brief Type alias for single qubit quantum kernels
   using one_qubit_encoding = cudaq::qkernel<void(patch)>;
diff --git a/libs/qec/include/cudaq/qec/codes/repetition.h b/libs/qec/include/cudaq/qec/codes/repetition.h
index 563b902d..bf52ce61 100644
--- a/libs/qec/include/cudaq/qec/codes/repetition.h
+++ b/libs/qec/include/cudaq/qec/codes/repetition.h
@@ -76,7 +76,7 @@ class repetition : public cudaq::qec::code {
   repetition(const heterogeneous_map &);
 
   /// @brief Factory function to create repetition code instances
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       repetition, static std::unique_ptr<cudaq::qec::code> create(
                       const cudaqx::heterogeneous_map &options) {
         return std::make_unique<repetition>(options);
diff --git a/libs/qec/include/cudaq/qec/codes/steane.h b/libs/qec/include/cudaq/qec/codes/steane.h
index a22e82a8..1a010d8e 100644
--- a/libs/qec/include/cudaq/qec/codes/steane.h
+++ b/libs/qec/include/cudaq/qec/codes/steane.h
@@ -132,7 +132,7 @@ class steane : public cudaq::qec::code {
   steane(const heterogeneous_map &);
 
   /// @brief Extension creator function for the Steane code
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       steane, static std::unique_ptr<cudaq::qec::code> create(
                   const cudaqx::heterogeneous_map &options) {
         return std::make_unique<steane>(options);
diff --git a/libs/qec/include/cudaq/qec/codes/surface_code.h b/libs/qec/include/cudaq/qec/codes/surface_code.h
index e3f86e6c..a145dab0 100644
--- a/libs/qec/include/cudaq/qec/codes/surface_code.h
+++ b/libs/qec/include/cudaq/qec/codes/surface_code.h
@@ -264,7 +264,7 @@ class surface_code : public cudaq::qec::code {
   // Grid constructor would be useful
 
   /// @brief Extension creator function for the surface_code
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       surface_code, static std::unique_ptr<cudaq::qec::code> create(
                         const cudaqx::heterogeneous_map &options) {
         return std::make_unique<surface_code>(options);
diff --git a/libs/qec/include/cudaq/qec/decoder.h b/libs/qec/include/cudaq/qec/decoder.h
index 68cfcefb..2d711629 100644
--- a/libs/qec/include/cudaq/qec/decoder.h
+++ b/libs/qec/include/cudaq/qec/decoder.h
@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "cuda-qx/core/extension_point.h"
 #include "cuda-qx/core/heterogeneous_map.h"
 #include "cuda-qx/core/tensor.h"
+#include "cudaq/utils/extension_point.h"
 #include <future>
 #include <optional>
 #include <vector>
@@ -121,8 +121,8 @@ class async_decoder_result {
 /// arbitrary constructor parameters that can be unique to each specific
 /// decoder.
 class decoder
-    : public cudaqx::extension_point<decoder, const cudaqx::tensor<uint8_t> &,
-                                     const cudaqx::heterogeneous_map &> {
+    : public cudaq::extension_point<decoder, const cudaqx::tensor<uint8_t> &,
+                                    const cudaqx::heterogeneous_map &> {
 public:
   decoder() = delete;
 
diff --git a/libs/qec/lib/code.cpp b/libs/qec/lib/code.cpp
index a8a4e07c..9e6cbe2b 100644
--- a/libs/qec/lib/code.cpp
+++ b/libs/qec/lib/code.cpp
@@ -9,7 +9,7 @@
 
 #include "device/memory_circuit.h"
 
-INSTANTIATE_REGISTRY(cudaq::qec::code, const cudaqx::heterogeneous_map &)
+CUDAQ_INSTANTIATE_REGISTRY(cudaq::qec::code, const cudaqx::heterogeneous_map &)
 
 namespace cudaq::qec {
 
diff --git a/libs/qec/lib/codes/repetition.cpp b/libs/qec/lib/codes/repetition.cpp
index 5608a85f..979875ca 100644
--- a/libs/qec/lib/codes/repetition.cpp
+++ b/libs/qec/lib/codes/repetition.cpp
@@ -55,6 +55,6 @@ repetition::repetition(const heterogeneous_map &options) : code() {
 }
 
 /// @brief Register the repetition code type
-CUDAQ_REGISTER_TYPE(repetition)
+CUDAQ_REGISTER_EXTENSION(repetition)
 
 } // namespace cudaq::qec::repetition
diff --git a/libs/qec/lib/codes/steane.cpp b/libs/qec/lib/codes/steane.cpp
index 7aacd1d6..4d6310d1 100644
--- a/libs/qec/lib/codes/steane.cpp
+++ b/libs/qec/lib/codes/steane.cpp
@@ -37,6 +37,6 @@ steane::steane(const heterogeneous_map &options) : code() {
 }
 
 /// @brief Register the Steane code type
-CUDAQ_REGISTER_TYPE(steane)
+CUDAQ_REGISTER_EXTENSION(steane)
 
 } // namespace cudaq::qec::steane
diff --git a/libs/qec/lib/codes/surface_code.cpp b/libs/qec/lib/codes/surface_code.cpp
index b6b5f43a..59fe39bd 100644
--- a/libs/qec/lib/codes/surface_code.cpp
+++ b/libs/qec/lib/codes/surface_code.cpp
@@ -401,6 +401,6 @@ std::size_t surface_code::get_num_z_stabilizers() const {
 }
 
 /// @brief Register the surace_code type
-CUDAQ_REGISTER_TYPE(surface_code)
+CUDAQ_REGISTER_EXTENSION(surface_code)
 
 } // namespace cudaq::qec::surface_code
diff --git a/libs/qec/lib/decoder.cpp b/libs/qec/lib/decoder.cpp
index d3679e71..43fb4564 100644
--- a/libs/qec/lib/decoder.cpp
+++ b/libs/qec/lib/decoder.cpp
@@ -15,9 +15,9 @@
 #include <filesystem>
 #include <vector>
 
-INSTANTIATE_REGISTRY(cudaq::qec::decoder, const cudaqx::tensor<uint8_t> &)
-INSTANTIATE_REGISTRY(cudaq::qec::decoder, const cudaqx::tensor<uint8_t> &,
-                     const cudaqx::heterogeneous_map &)
+CUDAQ_INSTANTIATE_REGISTRY(cudaq::qec::decoder, const cudaqx::tensor<uint8_t> &)
+CUDAQ_INSTANTIATE_REGISTRY(cudaq::qec::decoder, const cudaqx::tensor<uint8_t> &,
+                           const cudaqx::heterogeneous_map &)
 
 namespace cudaq::qec {
 
diff --git a/libs/qec/lib/decoders/plugins/example/single_error_lut_example.cpp b/libs/qec/lib/decoders/plugins/example/single_error_lut_example.cpp
index 1df26ef9..70787b28 100644
--- a/libs/qec/lib/decoders/plugins/example/single_error_lut_example.cpp
+++ b/libs/qec/lib/decoders/plugins/example/single_error_lut_example.cpp
@@ -78,7 +78,7 @@ class single_error_lut_example : public decoder {
 
   virtual ~single_error_lut_example() {}
 
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       single_error_lut_example, static std::unique_ptr<decoder> create(
                                     const cudaqx::tensor<uint8_t> &H,
                                     const cudaqx::heterogeneous_map &params) {
@@ -86,6 +86,6 @@ class single_error_lut_example : public decoder {
       })
 };
 
-CUDAQ_REGISTER_TYPE(single_error_lut_example)
+CUDAQ_REGISTER_EXTENSION(single_error_lut_example)
 
 } // namespace cudaq::qec
diff --git a/libs/qec/lib/decoders/single_error_lut.cpp b/libs/qec/lib/decoders/single_error_lut.cpp
index b4cd05fd..35861800 100644
--- a/libs/qec/lib/decoders/single_error_lut.cpp
+++ b/libs/qec/lib/decoders/single_error_lut.cpp
@@ -152,7 +152,7 @@ class single_error_lut : public decoder {
 
   virtual ~single_error_lut() {}
 
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       single_error_lut, static std::unique_ptr<decoder> create(
                             const cudaqx::tensor<uint8_t> &H,
                             const cudaqx::heterogeneous_map &params) {
@@ -160,6 +160,6 @@ class single_error_lut : public decoder {
       })
 };
 
-CUDAQ_REGISTER_TYPE(single_error_lut)
+CUDAQ_REGISTER_EXTENSION(single_error_lut)
 
 } // namespace cudaq::qec
diff --git a/libs/qec/unittests/decoders/sample_decoder.cpp b/libs/qec/unittests/decoders/sample_decoder.cpp
index bd7ae7b5..1dc0314f 100644
--- a/libs/qec/unittests/decoders/sample_decoder.cpp
+++ b/libs/qec/unittests/decoders/sample_decoder.cpp
@@ -33,7 +33,7 @@ class sample_decoder : public decoder {
 
   virtual ~sample_decoder() {}
 
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       sample_decoder, static std::unique_ptr<decoder> create(
                           const cudaqx::tensor<uint8_t> &H,
                           const cudaqx::heterogeneous_map &params) {
@@ -41,6 +41,6 @@ class sample_decoder : public decoder {
       })
 };
 
-CUDAQ_REGISTER_TYPE(sample_decoder)
+CUDAQ_REGISTER_EXTENSION(sample_decoder)
 
 } // namespace cudaq::qec
diff --git a/libs/solvers/include/cudaq/solvers/adapt.h b/libs/solvers/include/cudaq/solvers/adapt.h
index d25be1d6..8a7a5523 100644
--- a/libs/solvers/include/cudaq/solvers/adapt.h
+++ b/libs/solvers/include/cudaq/solvers/adapt.h
@@ -62,7 +62,7 @@ using result =
     std::tuple<double, std::vector<double>, std::vector<cudaq::spin_op>>;
 
 /// Abstract base class for ADAPT-VQE implementation
-class adapt_impl : public cudaqx::extension_point<adapt_impl> {
+class adapt_impl : public cudaq::extension_point<adapt_impl> {
 public:
   /// Run the ADAPT-VQE algorithm
   /// @param initState Initial state preparation quantum kernel
diff --git a/libs/solvers/include/cudaq/solvers/adapt/adapt_simulator.h b/libs/solvers/include/cudaq/solvers/adapt/adapt_simulator.h
index a9fca6be..6447c74f 100644
--- a/libs/solvers/include/cudaq/solvers/adapt/adapt_simulator.h
+++ b/libs/solvers/include/cudaq/solvers/adapt/adapt_simulator.h
@@ -38,12 +38,12 @@ class simulator : public adapt_impl {
   /// @brief Creator function for the simulator implementation
   /// @details This function is used by the extension point mechanism to create
   /// instances of the simulator class.
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(adapt_impl, simulator);
+  CUDAQ_ADD_EXTENSION_CREATOR_FUNCTION(adapt_impl, simulator);
 
   virtual ~simulator() {}
 };
 
 /// @brief Register the simulator type with the CUDA-Q framework
-CUDAQ_REGISTER_TYPE(simulator)
+CUDAQ_REGISTER_EXTENSION(simulator)
 
 } // namespace cudaq::solvers::adapt
diff --git a/libs/solvers/include/cudaq/solvers/observe_gradient.h b/libs/solvers/include/cudaq/solvers/observe_gradient.h
index 80c75979..63901f4f 100644
--- a/libs/solvers/include/cudaq/solvers/observe_gradient.h
+++ b/libs/solvers/include/cudaq/solvers/observe_gradient.h
@@ -36,7 +36,7 @@ struct observe_iteration {
 /// used in global optimization of expectation values in
 /// typical quantum variational tasks.
 class observe_gradient
-    : public cudaqx::extension_point<
+    : public cudaq::extension_point<
           observe_gradient, const ParameterizedKernel &, const spin_op &> {
 protected:
   /// The spin operator used in computing expectation values
@@ -110,9 +110,8 @@ class observe_gradient
   static std::unique_ptr<observe_gradient>
   get(const std::string &name, const ParameterizedKernel &kernel,
       const spin_op &op) {
-    return cudaqx::extension_point<observe_gradient,
-                                   const ParameterizedKernel &,
-                                   const spin_op &>::get(name, kernel, op);
+    return cudaq::extension_point<observe_gradient, const ParameterizedKernel &,
+                                  const spin_op &>::get(name, kernel, op);
   }
 
   void set_spin_op(const spin_op in_op) { op = in_op; }
diff --git a/libs/solvers/include/cudaq/solvers/observe_gradients/central_difference.h b/libs/solvers/include/cudaq/solvers/observe_gradients/central_difference.h
index d6d58a68..d8d0099b 100644
--- a/libs/solvers/include/cudaq/solvers/observe_gradients/central_difference.h
+++ b/libs/solvers/include/cudaq/solvers/observe_gradients/central_difference.h
@@ -24,7 +24,7 @@ class central_difference : public observe_gradient {
   void calculateGradient(const std::vector<double> &x, std::vector<double> &dx,
                          double exp_h) override;
 
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       central_difference,
       static std::unique_ptr<observe_gradient> create(
           const ParameterizedKernel &functor, const spin_op &op) {
@@ -32,6 +32,6 @@ class central_difference : public observe_gradient {
       })
 };
 
-CUDAQ_REGISTER_TYPE(central_difference)
+CUDAQ_REGISTER_EXTENSION(central_difference)
 
 } // namespace cudaq
diff --git a/libs/solvers/include/cudaq/solvers/observe_gradients/forward_difference.h b/libs/solvers/include/cudaq/solvers/observe_gradients/forward_difference.h
index becf2e4f..d4f715cf 100644
--- a/libs/solvers/include/cudaq/solvers/observe_gradients/forward_difference.h
+++ b/libs/solvers/include/cudaq/solvers/observe_gradients/forward_difference.h
@@ -23,12 +23,12 @@ class forward_difference : public observe_gradient {
 
   void calculateGradient(const std::vector<double> &x, std::vector<double> &dx,
                          double exp_h) override;
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       forward_difference,
       static std::unique_ptr<observe_gradient> create(
           const ParameterizedKernel &functor, const spin_op &op) {
         return std::make_unique<forward_difference>(functor, op);
       })
 };
-CUDAQ_REGISTER_TYPE(forward_difference)
+CUDAQ_REGISTER_EXTENSION(forward_difference)
 } // namespace cudaq
diff --git a/libs/solvers/include/cudaq/solvers/observe_gradients/parameter_shift.h b/libs/solvers/include/cudaq/solvers/observe_gradients/parameter_shift.h
index 1786755c..53b8fdf4 100644
--- a/libs/solvers/include/cudaq/solvers/observe_gradients/parameter_shift.h
+++ b/libs/solvers/include/cudaq/solvers/observe_gradients/parameter_shift.h
@@ -23,12 +23,12 @@ class parameter_shift : public observe_gradient {
 
   void calculateGradient(const std::vector<double> &x, std::vector<double> &dx,
                          double exp_h) override;
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION(
       parameter_shift,
       static std::unique_ptr<observe_gradient> create(
           const ParameterizedKernel &functor, const spin_op &op) {
         return std::make_unique<parameter_shift>(functor, op);
       })
 };
-CUDAQ_REGISTER_TYPE(parameter_shift)
+CUDAQ_REGISTER_EXTENSION(parameter_shift)
 } // namespace cudaq
diff --git a/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compiler.h b/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compiler.h
index 0c75e9ef..0606380a 100644
--- a/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compiler.h
+++ b/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compiler.h
@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "cuda-qx/core/extension_point.h"
 #include "cuda-qx/core/heterogeneous_map.h"
 #include "cuda-qx/core/tensor.h"
+#include "cudaq/utils/extension_point.h"
 
 #include "cudaq/spin_op.h"
 
@@ -20,7 +20,7 @@ namespace cudaq::solvers {
 /// and interface for clients to map fermionic molecular operators to
 /// `cudaq::spin_op` instances. The fermionic operator is represented
 /// via its one body and two body electron overlap integrals.
-class fermion_compiler : public cudaqx::extension_point<fermion_compiler> {
+class fermion_compiler : public cudaq::extension_point<fermion_compiler> {
 public:
   /// @brief Given a fermionic representation of an operator
   /// generate an equivalent operator on spins.
diff --git a/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compilers/bravyi_kitaev.h b/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compilers/bravyi_kitaev.h
index a999647a..6e5d0a4f 100644
--- a/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compilers/bravyi_kitaev.h
+++ b/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compilers/bravyi_kitaev.h
@@ -23,7 +23,7 @@ class bravyi_kitaev : public fermion_compiler {
                           const cudaqx::tensor<> &hpqrs,
                           const cudaqx::heterogeneous_map &options) override;
 
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(fermion_compiler, bravyi_kitaev)
+  CUDAQ_ADD_EXTENSION_CREATOR_FUNCTION(fermion_compiler, bravyi_kitaev)
 };
-CUDAQ_REGISTER_TYPE(bravyi_kitaev)
+CUDAQ_REGISTER_EXTENSION(bravyi_kitaev)
 } // namespace cudaq::solvers
diff --git a/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compilers/jordan_wigner.h b/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compilers/jordan_wigner.h
index a1a52606..2480463c 100644
--- a/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compilers/jordan_wigner.h
+++ b/libs/solvers/include/cudaq/solvers/operators/molecule/fermion_compilers/jordan_wigner.h
@@ -18,7 +18,7 @@ class jordan_wigner : public fermion_compiler {
                           const cudaqx::tensor<> &hpqrs,
                           const cudaqx::heterogeneous_map &options) override;
 
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(fermion_compiler, jordan_wigner)
+  CUDAQ_ADD_EXTENSION_CREATOR_FUNCTION(fermion_compiler, jordan_wigner)
 };
-CUDAQ_REGISTER_TYPE(jordan_wigner)
+CUDAQ_REGISTER_EXTENSION(jordan_wigner)
 } // namespace cudaq::solvers
diff --git a/libs/solvers/include/cudaq/solvers/operators/molecule/molecule_package_driver.h b/libs/solvers/include/cudaq/solvers/operators/molecule/molecule_package_driver.h
index 232c7230..b88bb6b4 100644
--- a/libs/solvers/include/cudaq/solvers/operators/molecule/molecule_package_driver.h
+++ b/libs/solvers/include/cudaq/solvers/operators/molecule/molecule_package_driver.h
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "cuda-qx/core/extension_point.h"
 #include "cuda-qx/core/tear_down.h"
+#include "cudaq/utils/extension_point.h"
 
 #include "cudaq/solvers/operators/molecule.h"
 
@@ -18,7 +18,7 @@ namespace cudaq::solvers {
 /// @brief MoleculePackageDriver provides an extensible interface for
 /// generating molecular Hamiltonians and associated metadata.
 class MoleculePackageDriver
-    : public cudaqx::extension_point<MoleculePackageDriver> {
+    : public cudaq::extension_point<MoleculePackageDriver> {
 public:
   /// @brief Return a `molecular_hamiltonian` described by the given
   /// geometry, basis set, spin, and charge. Optionally
diff --git a/libs/solvers/include/cudaq/solvers/operators/operator_pool.h b/libs/solvers/include/cudaq/solvers/operators/operator_pool.h
index c8e523fd..b8bff512 100644
--- a/libs/solvers/include/cudaq/solvers/operators/operator_pool.h
+++ b/libs/solvers/include/cudaq/solvers/operators/operator_pool.h
@@ -12,9 +12,9 @@
 #include <optional>
 #include <unordered_map>
 
-#include "cuda-qx/core/extension_point.h"
 #include "cuda-qx/core/heterogeneous_map.h"
 #include "cudaq/spin_op.h"
+#include "cudaq/utils/extension_point.h"
 
 using namespace cudaqx;
 
@@ -24,7 +24,7 @@ namespace cudaq::solvers {
 /// algorithms.
 /// @details This class extends the extension_point template, allowing for
 /// runtime extensibility.
-class operator_pool : public cudaqx::extension_point<operator_pool> {
+class operator_pool : public cudaq::extension_point<operator_pool> {
 public:
   /// @brief Default constructor.
   operator_pool() = default;
diff --git a/libs/solvers/include/cudaq/solvers/operators/operator_pools/qaoa_operator_pool.h b/libs/solvers/include/cudaq/solvers/operators/operator_pools/qaoa_operator_pool.h
index f839d843..58dc0e9d 100644
--- a/libs/solvers/include/cudaq/solvers/operators/operator_pools/qaoa_operator_pool.h
+++ b/libs/solvers/include/cudaq/solvers/operators/operator_pools/qaoa_operator_pool.h
@@ -32,13 +32,13 @@ class qaoa_pool : public operator_pool {
   /// extension
   /// @details This function is used by the extension point mechanism to create
   /// instances of the qaoa_pool class. The extension is registered with a name
-  CUDAQ_EXTENSION_CUSTOM_CREATOR_FUNCTION_WITH_NAME(
+  CUDAQ_ADD_EXTENSION_CUSTOM_CREATOR_FUNCTION_WITH_NAME(
       qaoa_pool, "qaoa", static std::unique_ptr<operator_pool> create() {
         return std::make_unique<qaoa_pool>();
       })
 };
 
 /// @brief Register the qaoa_pool extension type with the CUDA-Q framework
-CUDAQ_REGISTER_TYPE(qaoa_pool)
+CUDAQ_REGISTER_EXTENSION(qaoa_pool)
 
 } // namespace cudaq::solvers
diff --git a/libs/solvers/include/cudaq/solvers/operators/operator_pools/spin_complement_gsd.h b/libs/solvers/include/cudaq/solvers/operators/operator_pools/spin_complement_gsd.h
index 5a3196e9..8f0bc342 100644
--- a/libs/solvers/include/cudaq/solvers/operators/operator_pools/spin_complement_gsd.h
+++ b/libs/solvers/include/cudaq/solvers/operators/operator_pools/spin_complement_gsd.h
@@ -37,9 +37,9 @@ class spin_complement_gsd : public operator_pool {
   /// spin_complement_gsd extension
   /// @details This function is used by the extension point mechanism to create
   /// instances of the spin_complement_gsd class.
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(operator_pool, spin_complement_gsd)
+  CUDAQ_ADD_EXTENSION_CREATOR_FUNCTION(operator_pool, spin_complement_gsd)
 };
 /// @brief Register the spin_complement_gsd extension type with the CUDA-Q
 /// framework
-CUDAQ_REGISTER_TYPE(spin_complement_gsd)
+CUDAQ_REGISTER_EXTENSION(spin_complement_gsd)
 } // namespace cudaq::solvers
diff --git a/libs/solvers/include/cudaq/solvers/operators/operator_pools/uccsd_operator_pool.h b/libs/solvers/include/cudaq/solvers/operators/operator_pools/uccsd_operator_pool.h
index c2df7e1d..e7391d22 100644
--- a/libs/solvers/include/cudaq/solvers/operators/operator_pools/uccsd_operator_pool.h
+++ b/libs/solvers/include/cudaq/solvers/operators/operator_pools/uccsd_operator_pool.h
@@ -35,9 +35,9 @@ class uccsd : public operator_pool {
   /// @brief Call to macro for defining the creator function for an extension
   /// @details This function is used by the extension point mechanism to create
   /// instances of the uccsd class.
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(operator_pool, uccsd)
+  CUDAQ_ADD_EXTENSION_CREATOR_FUNCTION(operator_pool, uccsd)
 };
 /// @brief Register the uccsd extension type with the CUDA-Q framework
-CUDAQ_REGISTER_TYPE(uccsd)
+CUDAQ_REGISTER_EXTENSION(uccsd)
 
 } // namespace cudaq::solvers
diff --git a/libs/solvers/include/cudaq/solvers/optimizer.h b/libs/solvers/include/cudaq/solvers/optimizer.h
index 06e9ee50..50775533 100644
--- a/libs/solvers/include/cudaq/solvers/optimizer.h
+++ b/libs/solvers/include/cudaq/solvers/optimizer.h
@@ -11,8 +11,8 @@
 #include <cassert>
 #include <optional>
 
-#include "cuda-qx/core/extension_point.h"
 #include "cuda-qx/core/heterogeneous_map.h"
+#include "cudaq/utils/extension_point.h"
 
 using namespace cudaqx;
 
@@ -87,7 +87,7 @@ class optimizable_function {
 /// requires gradients or not. Parameterizing optimization strategies
 /// is left as a task for sub-types (things like initial parameters, max
 /// function evaluations, etc.).
-class optimizer : public cudaqx::extension_point<optimizer> {
+class optimizer : public cudaq::extension_point<optimizer> {
 public:
   virtual ~optimizer() = default;
 
diff --git a/libs/solvers/include/cudaq/solvers/optimizers/cobyla.h b/libs/solvers/include/cudaq/solvers/optimizers/cobyla.h
index 9b23f7d0..c65c3850 100644
--- a/libs/solvers/include/cudaq/solvers/optimizers/cobyla.h
+++ b/libs/solvers/include/cudaq/solvers/optimizers/cobyla.h
@@ -29,9 +29,9 @@ class cobyla : public optimizer {
                                const optimizable_function &opt_function,
                                const heterogeneous_map &options) override;
 
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(optimizer, cobyla);
+  CUDAQ_ADD_EXTENSION_CREATOR_FUNCTION(optimizer, cobyla);
 };
 
-CUDAQ_REGISTER_TYPE(cobyla)
+CUDAQ_REGISTER_EXTENSION(cobyla)
 
 } // namespace cudaq::optim
diff --git a/libs/solvers/include/cudaq/solvers/optimizers/lbfgs.h b/libs/solvers/include/cudaq/solvers/optimizers/lbfgs.h
index 8c5ad3b5..24915d8c 100644
--- a/libs/solvers/include/cudaq/solvers/optimizers/lbfgs.h
+++ b/libs/solvers/include/cudaq/solvers/optimizers/lbfgs.h
@@ -30,7 +30,7 @@ class lbfgs : public optimizer {
   optimize(std::size_t dim, const optimizable_function &opt_function,
            const cudaqx::heterogeneous_map &options) override;
 
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(optimizer, lbfgs)
+  CUDAQ_ADD_EXTENSION_CREATOR_FUNCTION(optimizer, lbfgs)
 };
-CUDAQ_REGISTER_TYPE(lbfgs)
+CUDAQ_REGISTER_EXTENSION(lbfgs)
 } // namespace cudaq::optim
diff --git a/libs/solvers/lib/adapt/adapt.cpp b/libs/solvers/lib/adapt/adapt.cpp
index 92b54542..2417c20b 100644
--- a/libs/solvers/lib/adapt/adapt.cpp
+++ b/libs/solvers/lib/adapt/adapt.cpp
@@ -11,4 +11,4 @@
 
 #include "cudaq/solvers/adapt.h"
 
-INSTANTIATE_REGISTRY_NO_ARGS(cudaq::solvers::adapt::adapt_impl)
+CUDAQ_INSTANTIATE_REGISTRY_NO_ARGS(cudaq::solvers::adapt::adapt_impl)
diff --git a/libs/solvers/lib/observe_gradients/observe_gradient.cpp b/libs/solvers/lib/observe_gradients/observe_gradient.cpp
index 1376e2f7..84c13ac0 100644
--- a/libs/solvers/lib/observe_gradients/observe_gradient.cpp
+++ b/libs/solvers/lib/observe_gradients/observe_gradient.cpp
@@ -9,6 +9,6 @@
 
 #include "cudaq/solvers/observe_gradient.h"
 
-INSTANTIATE_REGISTRY(cudaq::observe_gradient,
-                     std::function<void(std::vector<double>)> const &,
-                     cudaq::spin_op const &)
+CUDAQ_INSTANTIATE_REGISTRY(cudaq::observe_gradient,
+                           std::function<void(std::vector<double>)> const &,
+                           cudaq::spin_op const &)
diff --git a/libs/solvers/lib/operators/molecule/drivers/pyscf_driver.cpp b/libs/solvers/lib/operators/molecule/drivers/pyscf_driver.cpp
index c73768df..97d8fde6 100644
--- a/libs/solvers/lib/operators/molecule/drivers/pyscf_driver.cpp
+++ b/libs/solvers/lib/operators/molecule/drivers/pyscf_driver.cpp
@@ -43,7 +43,7 @@ class PySCFTearDown : public tear_down {
 class RESTPySCFDriver : public MoleculePackageDriver {
 
 public:
-  CUDAQ_EXTENSION_CREATOR_FUNCTION(MoleculePackageDriver, RESTPySCFDriver)
+  CUDAQ_ADD_EXTENSION_CREATOR_FUNCTION(MoleculePackageDriver, RESTPySCFDriver)
 
   bool is_available() const override {
     cudaq::RestClient client;
@@ -191,6 +191,6 @@ class RESTPySCFDriver : public MoleculePackageDriver {
                                  num_electrons,   numOrb, energies};
   }
 };
-CUDAQ_REGISTER_TYPE(RESTPySCFDriver)
+CUDAQ_REGISTER_EXTENSION(RESTPySCFDriver)
 
 } // namespace cudaq::solvers
diff --git a/libs/solvers/lib/operators/molecule/fermion_compilers/fermion_compiler.cpp b/libs/solvers/lib/operators/molecule/fermion_compilers/fermion_compiler.cpp
index e4f03e2d..a9b41379 100644
--- a/libs/solvers/lib/operators/molecule/fermion_compilers/fermion_compiler.cpp
+++ b/libs/solvers/lib/operators/molecule/fermion_compilers/fermion_compiler.cpp
@@ -7,4 +7,4 @@
  ******************************************************************************/
 #include "cudaq/solvers/operators/molecule/fermion_compiler.h"
 
-INSTANTIATE_REGISTRY_NO_ARGS(cudaq::solvers::fermion_compiler)
+CUDAQ_INSTANTIATE_REGISTRY_NO_ARGS(cudaq::solvers::fermion_compiler)
diff --git a/libs/solvers/lib/operators/molecule/molecule.cpp b/libs/solvers/lib/operators/molecule/molecule.cpp
index 05a08347..121a2777 100644
--- a/libs/solvers/lib/operators/molecule/molecule.cpp
+++ b/libs/solvers/lib/operators/molecule/molecule.cpp
@@ -11,7 +11,7 @@
 #include <fstream>
 #include <iostream>
 
-INSTANTIATE_REGISTRY_NO_ARGS(cudaq::solvers::MoleculePackageDriver)
+CUDAQ_INSTANTIATE_REGISTRY_NO_ARGS(cudaq::solvers::MoleculePackageDriver)
 
 namespace cudaq::solvers {
 
diff --git a/libs/solvers/lib/operators/operator_pools/operator_pool.cpp b/libs/solvers/lib/operators/operator_pools/operator_pool.cpp
index 99cb5129..ed4f2c82 100644
--- a/libs/solvers/lib/operators/operator_pools/operator_pool.cpp
+++ b/libs/solvers/lib/operators/operator_pools/operator_pool.cpp
@@ -8,7 +8,7 @@
 
 #include "cudaq/solvers/operators/operator_pool.h"
 
-INSTANTIATE_REGISTRY_NO_ARGS(cudaq::solvers::operator_pool)
+CUDAQ_INSTANTIATE_REGISTRY_NO_ARGS(cudaq::solvers::operator_pool)
 
 namespace cudaq::solvers {
 std::vector<cudaq::spin_op>
diff --git a/libs/solvers/lib/optimizers/optimizer.cpp b/libs/solvers/lib/optimizers/optimizer.cpp
index b14f8809..8abd7517 100644
--- a/libs/solvers/lib/optimizers/optimizer.cpp
+++ b/libs/solvers/lib/optimizers/optimizer.cpp
@@ -8,4 +8,4 @@
 
 #include "cudaq/solvers/optimizer.h"
 
-INSTANTIATE_REGISTRY_NO_ARGS(cudaq::optim::optimizer)
+CUDAQ_INSTANTIATE_REGISTRY_NO_ARGS(cudaq::optim::optimizer)