diff --git a/csrc/mmdeploy/apis/c/mmdeploy/executor.cpp b/csrc/mmdeploy/apis/c/mmdeploy/executor.cpp
index 998df35cd9..aa1966d30b 100644
--- a/csrc/mmdeploy/apis/c/mmdeploy/executor.cpp
+++ b/csrc/mmdeploy/apis/c/mmdeploy/executor.cpp
@@ -13,10 +13,10 @@ namespace {
 
 mmdeploy_scheduler_t CreateScheduler(const char* type, const Value& config = Value()) {
   try {
-    auto creator = Registry<SchedulerType>::Get().GetCreator(type);
+    auto creator = gRegistry<SchedulerType>().Get(type);
     if (!creator) {
       MMDEPLOY_ERROR("Creator for {} not found. Available schedulers: {}", type,
-                     Registry<SchedulerType>::Get().List());
+                     gRegistry<SchedulerType>().List());
       return nullptr;
     }
     return Cast(new SchedulerType(creator->Create(config)));
diff --git a/csrc/mmdeploy/apis/python/detector.cpp b/csrc/mmdeploy/apis/python/detector.cpp
index 862132afc8..057a92ab00 100644
--- a/csrc/mmdeploy/apis/python/detector.cpp
+++ b/csrc/mmdeploy/apis/python/detector.cpp
@@ -28,12 +28,16 @@ class PyDetector {
     if (status != MMDEPLOY_SUCCESS) {
       throw std::runtime_error("failed to apply detector, code: " + std::to_string(status));
     }
+    using Sptr = std::shared_ptr<mmdeploy_detection_t>;
+    Sptr holder(detection, [result_count, n = mats.size()](auto p) {
+      mmdeploy_detector_release_result(p, result_count, n);
+    });
     auto output = py::list{};
     auto result = detection;
     for (int i = 0; i < mats.size(); ++i) {
       auto bboxes = py::array_t<float>({result_count[i], 5});
       auto labels = py::array_t<int>(result_count[i]);
-      auto masks = std::vector<py::array_t<uint8_t>>{};
+      auto masks = std::vector<py::array>();
       masks.reserve(result_count[i]);
       for (int j = 0; j < result_count[i]; ++j, ++result) {
         auto bbox = bboxes.mutable_data(j);
@@ -44,16 +48,16 @@ class PyDetector {
         bbox[4] = result->score;
         labels.mutable_at(j) = result->label_id;
         if (result->mask) {
-          py::array_t<uint8_t> mask({result->mask->height, result->mask->width});
-          memcpy(mask.mutable_data(), result->mask->data, mask.nbytes());
-          masks.push_back(std::move(mask));
+          masks.emplace_back(std::array{result->mask->height, result->mask->width},  // shape
+                             reinterpret_cast<uint8_t*>(result->mask->data),         // data
+                             py::capsule(new Sptr(holder),                           // handle
+                                         [](void* p) { delete reinterpret_cast<Sptr*>(p); }));
         } else {
           masks.emplace_back();
         }
       }
       output.append(py::make_tuple(std::move(bboxes), std::move(labels), std::move(masks)));
     }
-    mmdeploy_detector_release_result(detection, result_count, (int)mats.size());
     return output;
   }
   ~PyDetector() {
diff --git a/csrc/mmdeploy/apis/python/restorer.cpp b/csrc/mmdeploy/apis/python/restorer.cpp
index e4ec5ef83c..771af2a6c4 100644
--- a/csrc/mmdeploy/apis/python/restorer.cpp
+++ b/csrc/mmdeploy/apis/python/restorer.cpp
@@ -19,7 +19,7 @@ class PyRestorer {
     restorer_ = {};
   }
 
-  std::vector<py::array_t<uint8_t>> Apply(const std::vector<PyImage>& imgs) {
+  std::vector<py::array> Apply(const std::vector<PyImage>& imgs) {
     std::vector<mmdeploy_mat_t> mats;
     mats.reserve(imgs.size());
     for (const auto& img : imgs) {
@@ -31,15 +31,19 @@ class PyRestorer {
     if (status != MMDEPLOY_SUCCESS) {
       throw std::runtime_error("failed to apply restorer, code: " + std::to_string(status));
     }
-    auto output = std::vector<py::array_t<uint8_t>>{};
-    output.reserve(mats.size());
+    using Sptr = std::shared_ptr<mmdeploy_mat_t>;
+    Sptr holder(results, [n = mats.size()](auto p) { mmdeploy_restorer_release_result(p, n); });
+
+    std::vector<py::array> rets(mats.size());
     for (int i = 0; i < mats.size(); ++i) {
-      py::array_t<uint8_t> restored({results[i].height, results[i].width, results[i].channel});
-      memcpy(restored.mutable_data(), results[i].data, restored.nbytes());
-      output.push_back(std::move(restored));
+      rets[i] = {
+          {results[i].height, results[i].width, results[i].channel},       // shape
+          results[i].data,                                                 // data
+          py::capsule(new Sptr(holder),                                    // handle
+                      [](void* p) { delete reinterpret_cast<Sptr*>(p); })  //
+      };
     }
-    mmdeploy_restorer_release_result(results, (int)mats.size());
-    return output;
+    return rets;
   }
 
  private:
diff --git a/csrc/mmdeploy/apis/python/segmentor.cpp b/csrc/mmdeploy/apis/python/segmentor.cpp
index e148ceda12..1fdf719fc8 100644
--- a/csrc/mmdeploy/apis/python/segmentor.cpp
+++ b/csrc/mmdeploy/apis/python/segmentor.cpp
@@ -20,7 +20,7 @@ class PySegmentor {
     segmentor_ = {};
   }
 
-  std::vector<py::array_t<int>> Apply(const std::vector<PyImage>& imgs) {
+  std::vector<py::array> Apply(const std::vector<PyImage>& imgs) {
     std::vector<mmdeploy_mat_t> mats;
     mats.reserve(imgs.size());
     for (const auto& img : imgs) {
@@ -32,15 +32,19 @@ class PySegmentor {
     if (status != MMDEPLOY_SUCCESS) {
       throw std::runtime_error("failed to apply segmentor, code: " + std::to_string(status));
     }
-    auto output = std::vector<py::array_t<int>>{};
-    output.reserve(mats.size());
-    for (int i = 0; i < mats.size(); ++i) {
-      auto mask = py::array_t<int>({segm[i].height, segm[i].width});
-      memcpy(mask.mutable_data(), segm[i].mask, mask.nbytes());
-      output.push_back(std::move(mask));
+    using Sptr = std::shared_ptr<mmdeploy_segmentation_t>;
+    Sptr holder(segm, [n = mats.size()](auto p) { mmdeploy_segmentor_release_result(p, n); });
+
+    std::vector<py::array> rets(mats.size());
+    for (size_t i = 0; i < mats.size(); ++i) {
+      rets[i] = {
+          {segm[i].height, segm[i].width},                                 // shape
+          segm[i].mask,                                                    // data
+          py::capsule(new Sptr(holder),                                    // handle
+                      [](void* p) { delete reinterpret_cast<Sptr*>(p); })  //
+      };
     }
-    mmdeploy_segmentor_release_result(segm, (int)mats.size());
-    return output;
+    return rets;
   }
 
  private:
diff --git a/csrc/mmdeploy/backend_ops/onnxruntime/grid_sample/grid_sample.cpp b/csrc/mmdeploy/backend_ops/onnxruntime/grid_sample/grid_sample.cpp
index 8850b0539a..c7fed37d23 100644
--- a/csrc/mmdeploy/backend_ops/onnxruntime/grid_sample/grid_sample.cpp
+++ b/csrc/mmdeploy/backend_ops/onnxruntime/grid_sample/grid_sample.cpp
@@ -13,8 +13,8 @@ namespace mmdeploy {
 #define MAX(a, b) (((a) < (b)) ? (b) : (a))
 #define CLIP_COORDINATES(in, out, clip_limit) out = MIN((clip_limit - 1), MAX(in, 0))
 
-GridSampleKernel::GridSampleKernel(OrtApi api, const OrtKernelInfo *info)
-    : api_(api), ort_(api_), info_(info) {
+GridSampleKernel::GridSampleKernel(const OrtApi &api, const OrtKernelInfo *info)
+    : ort_(api), info_(info) {
   align_corners_ = ort_.KernelInfoGetAttribute<int64_t>(info, "align_corners");
   interpolation_mode_ = ort_.KernelInfoGetAttribute<int64_t>(info, "interpolation_mode");
   padding_mode_ = ort_.KernelInfoGetAttribute<int64_t>(info, "padding_mode");
diff --git a/csrc/mmdeploy/backend_ops/onnxruntime/grid_sample/grid_sample.h b/csrc/mmdeploy/backend_ops/onnxruntime/grid_sample/grid_sample.h
index afdb04d14c..2581b7833e 100644
--- a/csrc/mmdeploy/backend_ops/onnxruntime/grid_sample/grid_sample.h
+++ b/csrc/mmdeploy/backend_ops/onnxruntime/grid_sample/grid_sample.h
@@ -7,12 +7,11 @@
 namespace mmdeploy {
 
 struct GridSampleKernel {
-  GridSampleKernel(OrtApi api, const OrtKernelInfo *info);
+  GridSampleKernel(const OrtApi &api, const OrtKernelInfo *info);
 
   void Compute(OrtKernelContext *context);
 
  protected:
-  OrtApi api_;
   Ort::CustomOpApi ort_;
   const OrtKernelInfo *info_;
   Ort::AllocatorWithDefaultOptions allocator_;
@@ -23,7 +22,7 @@ struct GridSampleKernel {
 };
 
 struct GridSampleOp : Ort::CustomOpBase<GridSampleOp, GridSampleKernel> {
-  void *CreateKernel(OrtApi api, const OrtKernelInfo *info) const {
+  void *CreateKernel(const OrtApi &api, const OrtKernelInfo *info) const {
     return new GridSampleKernel(api, info);
   };
 
diff --git a/csrc/mmdeploy/backend_ops/onnxruntime/modulated_deform_conv/modulated_deform_conv.cpp b/csrc/mmdeploy/backend_ops/onnxruntime/modulated_deform_conv/modulated_deform_conv.cpp
index 3df1217a37..818e2fa6c2 100644
--- a/csrc/mmdeploy/backend_ops/onnxruntime/modulated_deform_conv/modulated_deform_conv.cpp
+++ b/csrc/mmdeploy/backend_ops/onnxruntime/modulated_deform_conv/modulated_deform_conv.cpp
@@ -109,8 +109,9 @@ void deformable_conv2d_ref_fp32(const float *src, const float *offset, const flo
   }
 }
 
-MMCVModulatedDeformConvKernel::MMCVModulatedDeformConvKernel(OrtApi api, const OrtKernelInfo *info)
-    : api_(api), ort_(api_), info_(info) {
+MMCVModulatedDeformConvKernel::MMCVModulatedDeformConvKernel(const OrtApi &api,
+                                                             const OrtKernelInfo *info)
+    : ort_(api), info_(info) {
   std::vector<int64_t> stride = ort_.KernelInfoGetAttribute<std::vector<int64_t>>(info, "stride");
   stride_height_ = stride[0];
   stride_width_ = stride[1];
diff --git a/csrc/mmdeploy/backend_ops/onnxruntime/modulated_deform_conv/modulated_deform_conv.h b/csrc/mmdeploy/backend_ops/onnxruntime/modulated_deform_conv/modulated_deform_conv.h
index 6ed6be5ce5..772a9c4a88 100644
--- a/csrc/mmdeploy/backend_ops/onnxruntime/modulated_deform_conv/modulated_deform_conv.h
+++ b/csrc/mmdeploy/backend_ops/onnxruntime/modulated_deform_conv/modulated_deform_conv.h
@@ -7,12 +7,11 @@
 namespace mmdeploy {
 
 struct MMCVModulatedDeformConvKernel {
-  MMCVModulatedDeformConvKernel(OrtApi api, const OrtKernelInfo *info);
+  MMCVModulatedDeformConvKernel(const OrtApi &api, const OrtKernelInfo *info);
 
   void Compute(OrtKernelContext *context);
 
  protected:
-  OrtApi api_;
   Ort::CustomOpApi ort_;
   const OrtKernelInfo *info_;
   Ort::AllocatorWithDefaultOptions allocator_;
@@ -29,7 +28,7 @@ struct MMCVModulatedDeformConvKernel {
 
 struct MMCVModulatedDeformConvOp
     : Ort::CustomOpBase<MMCVModulatedDeformConvOp, MMCVModulatedDeformConvKernel> {
-  void *CreateKernel(OrtApi api, const OrtKernelInfo *info) const {
+  void *CreateKernel(const OrtApi &api, const OrtKernelInfo *info) const {
     return new MMCVModulatedDeformConvKernel(api, info);
   }
 
diff --git a/csrc/mmdeploy/backend_ops/onnxruntime/nms_rotated/nms_rotated.cpp b/csrc/mmdeploy/backend_ops/onnxruntime/nms_rotated/nms_rotated.cpp
index 6052195a52..9da0091049 100644
--- a/csrc/mmdeploy/backend_ops/onnxruntime/nms_rotated/nms_rotated.cpp
+++ b/csrc/mmdeploy/backend_ops/onnxruntime/nms_rotated/nms_rotated.cpp
@@ -261,8 +261,8 @@ float rotated_boxes_intersection(const RotatedBox& box1, const RotatedBox& box2)
   return polygon_area(orderedPts, num_convex);
 }
 
-NMSRotatedKernel::NMSRotatedKernel(OrtApi api, const OrtKernelInfo* info)
-    : api_(api), ort_(api_), info_(info) {
+NMSRotatedKernel::NMSRotatedKernel(const OrtApi& api, const OrtKernelInfo* info)
+    : ort_(api), info_(info) {
   iou_threshold_ = ort_.KernelInfoGetAttribute<float>(info, "iou_threshold");
   score_threshold_ = ort_.KernelInfoGetAttribute<float>(info, "score_threshold");
 
diff --git a/csrc/mmdeploy/backend_ops/onnxruntime/nms_rotated/nms_rotated.h b/csrc/mmdeploy/backend_ops/onnxruntime/nms_rotated/nms_rotated.h
index c1a12dad16..6ed44ce410 100644
--- a/csrc/mmdeploy/backend_ops/onnxruntime/nms_rotated/nms_rotated.h
+++ b/csrc/mmdeploy/backend_ops/onnxruntime/nms_rotated/nms_rotated.h
@@ -12,12 +12,11 @@
 
 namespace mmdeploy {
 struct NMSRotatedKernel {
-  NMSRotatedKernel(OrtApi api, const OrtKernelInfo* info);
+  NMSRotatedKernel(const OrtApi& api, const OrtKernelInfo* info);
 
   void Compute(OrtKernelContext* context);
 
  private:
-  OrtApi api_;
   Ort::CustomOpApi ort_;
   const OrtKernelInfo* info_;
   Ort::AllocatorWithDefaultOptions allocator_;
@@ -26,7 +25,7 @@ struct NMSRotatedKernel {
 };
 
 struct NMSRotatedOp : Ort::CustomOpBase<NMSRotatedOp, NMSRotatedKernel> {
-  void* CreateKernel(OrtApi api, const OrtKernelInfo* info) const {
+  void* CreateKernel(const OrtApi& api, const OrtKernelInfo* info) const {
     return new NMSRotatedKernel(api, info);
   }
   const char* GetName() const { return "NMSRotated"; }
diff --git a/csrc/mmdeploy/codebase/common.h b/csrc/mmdeploy/codebase/common.h
index 510f1b8bad..391f177590 100644
--- a/csrc/mmdeploy/codebase/common.h
+++ b/csrc/mmdeploy/codebase/common.h
@@ -32,8 +32,7 @@ class Context {
 template <class Tag>
 class CodebaseCreator : public Creator<Module> {
  public:
-  const char* GetName() const override { return Tag::name; }
-  int GetVersion() const override { return 1; }
+  std::string_view name() const noexcept override { return Tag::name; }
   std::unique_ptr<Module> Create(const Value& cfg) override {
     constexpr auto key{"component"};
     if (!cfg.contains(key)) {
@@ -45,36 +44,34 @@ class CodebaseCreator : public Creator<Module> {
       throw_exception(eInvalidArgument);
     }
     auto postprocess_type = cfg[key].get<std::string>();
-    auto creator = Registry<Tag>::Get().GetCreator(postprocess_type);
+    auto creator = gRegistry<Tag>().Get(postprocess_type);
     if (creator == nullptr) {
       MMDEPLOY_ERROR("Could not found entry '{}' in {}. Available components: {}", postprocess_type,
-                     Tag::name, Registry<Tag>::Get().List());
+                     Tag::name, gRegistry<Tag>().List());
       throw_exception(eEntryNotFound);
     }
     return creator->Create(cfg);
   }
 };
 
-#define DECLARE_CODEBASE(codebase_type, codebase_name)               \
+#define MMDEPLOY_DECLARE_CODEBASE(codebase_type, codebase_name)      \
   class codebase_type : public Context {                             \
    public:                                                           \
     static constexpr const auto name = #codebase_name;               \
     using type = std::unique_ptr<Module>;                            \
     explicit codebase_type(const Value& config) : Context(config) {} \
-  };
+  };                                                                 \
+  MMDEPLOY_DECLARE_REGISTRY(codebase_type, std::unique_ptr<Module>(const Value& config));
 
-#define REGISTER_CODEBASE(codebase)                       \
+#define MMDEPLOY_REGISTER_CODEBASE(codebase)              \
   using codebase##_##Creator = CodebaseCreator<codebase>; \
-  REGISTER_MODULE(Module, codebase##_##Creator)
+  MMDEPLOY_REGISTER_CREATOR(Module, codebase##_##Creator) \
+  MMDEPLOY_DEFINE_REGISTRY(codebase)
 
-#define REGISTER_CODEBASE_COMPONENT(codebase, component_type)                                      \
-  class component_type##_##Creator : public Creator<codebase> {                                    \
-   public:                                                                                         \
-    const char* GetName() const override { return #component_type; }                               \
-    int GetVersion() const override { return 1; }                                                  \
-    ReturnType Create(const Value& config) override { return CreateTask(component_type(config)); } \
-  };                                                                                               \
-  REGISTER_MODULE(codebase, component_type##_##Creator)
+#define MMDEPLOY_REGISTER_CODEBASE_COMPONENT(codebase, component_type)                    \
+  MMDEPLOY_REGISTER_FACTORY_FUNC(codebase, (component_type, 0), [](const Value& config) { \
+    return CreateTask(component_type(config));                                            \
+  })
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/codebase/mmaction/base_head.cpp b/csrc/mmdeploy/codebase/mmaction/base_head.cpp
index a26a9a030c..931c9663eb 100644
--- a/csrc/mmdeploy/codebase/mmaction/base_head.cpp
+++ b/csrc/mmdeploy/codebase/mmaction/base_head.cpp
@@ -61,10 +61,12 @@ class BaseHead : public MMAction {
   int topk_{1};
 };
 
-REGISTER_CODEBASE_COMPONENT(MMAction, BaseHead);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMAction, BaseHead);
+
 using SlowFastHead = BaseHead;
-REGISTER_CODEBASE_COMPONENT(MMAction, SlowFastHead);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMAction, SlowFastHead);
+
 using TSNHead = BaseHead;
-REGISTER_CODEBASE_COMPONENT(MMAction, TSNHead);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMAction, TSNHead);
 
 }  // namespace mmdeploy::mmaction
diff --git a/csrc/mmdeploy/codebase/mmaction/cpu/format_shape_impl.cpp b/csrc/mmdeploy/codebase/mmaction/cpu/format_shape_impl.cpp
index 16a788fc52..5cdd11b16f 100644
--- a/csrc/mmdeploy/codebase/mmaction/cpu/format_shape_impl.cpp
+++ b/csrc/mmdeploy/codebase/mmaction/cpu/format_shape_impl.cpp
@@ -123,16 +123,7 @@ class FormatShapeImpl : public ::mmdeploy::FormatShapeImpl {
   constexpr static Device kHost{0, 0};
 };
 
-class FormatShapeImplCreator : public Creator<::mmdeploy::FormatShapeImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<FormatShapeImpl>(args); }
-};
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::FormatShapeImpl, (cpu, 0), FormatShapeImpl);
 
 }  // namespace cpu
 }  // namespace mmdeploy
-
-using ::mmdeploy::FormatShapeImpl;
-using ::mmdeploy::cpu::FormatShapeImplCreator;
-REGISTER_MODULE(FormatShapeImpl, FormatShapeImplCreator);
diff --git a/csrc/mmdeploy/codebase/mmaction/cuda/format_shape_impl.cpp b/csrc/mmdeploy/codebase/mmaction/cuda/format_shape_impl.cpp
index 8e5a24316d..fccc0b2c8d 100644
--- a/csrc/mmdeploy/codebase/mmaction/cuda/format_shape_impl.cpp
+++ b/csrc/mmdeploy/codebase/mmaction/cuda/format_shape_impl.cpp
@@ -114,16 +114,7 @@ class FormatShapeImpl : public ::mmdeploy::FormatShapeImpl {
   }
 };
 
-class FormatShapeImplCreator : public Creator<::mmdeploy::FormatShapeImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<FormatShapeImpl>(args); }
-};
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::FormatShapeImpl, (cuda, 0), FormatShapeImpl);
 
 }  // namespace cuda
 }  // namespace mmdeploy
-
-using ::mmdeploy::FormatShapeImpl;
-using ::mmdeploy::cuda::FormatShapeImplCreator;
-REGISTER_MODULE(FormatShapeImpl, FormatShapeImplCreator);
diff --git a/csrc/mmdeploy/codebase/mmaction/format_shape.cpp b/csrc/mmdeploy/codebase/mmaction/format_shape.cpp
index f8163aea8e..d9893ad44d 100644
--- a/csrc/mmdeploy/codebase/mmaction/format_shape.cpp
+++ b/csrc/mmdeploy/codebase/mmaction/format_shape.cpp
@@ -58,7 +58,7 @@ Result<Value> FormatShapeImpl::Process(const Value& input) {
 class FormatShape : public Transform {
  public:
   explicit FormatShape(const Value& args, int version = 0) : Transform(args) {
-    auto impl_creator = Registry<FormatShapeImpl>::Get().GetCreator(specified_platform_, version);
+    auto impl_creator = gRegistry<FormatShapeImpl>().Get(specified_platform_, version);
     if (nullptr == impl_creator) {
       MMDEPLOY_ERROR("'FormatShape' is not supported on '{}' platform", specified_platform_);
       throw std::domain_error("'FormatShape' is not supported on specified platform");
@@ -73,17 +73,10 @@ class FormatShape : public Transform {
   std::unique_ptr<FormatShapeImpl> impl_;
 };
 
-class FormatShapeCreator : public Creator<Transform> {
- public:
-  const char* GetName(void) const override { return "FormatShape"; }
-  int GetVersion(void) const override { return version_; }
-  ReturnType Create(const Value& args) override { return make_unique<FormatShape>(args, version_); }
-
- private:
-  int version_{1};
-};
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (FormatShape, 0), [](const Value& config) {
+  return std::make_unique<FormatShape>(config, 0);
+});
 
-REGISTER_MODULE(Transform, FormatShapeCreator);
 MMDEPLOY_DEFINE_REGISTRY(FormatShapeImpl);
 
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/codebase/mmaction/format_shape.h b/csrc/mmdeploy/codebase/mmaction/format_shape.h
index 7fb4ff990f..4dcab6d730 100644
--- a/csrc/mmdeploy/codebase/mmaction/format_shape.h
+++ b/csrc/mmdeploy/codebase/mmaction/format_shape.h
@@ -30,7 +30,7 @@ class FormatShapeImpl : public TransformImpl {
   ArgType arg_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(FormatShapeImpl);
+MMDEPLOY_DECLARE_REGISTRY(FormatShapeImpl, std::unique_ptr<FormatShapeImpl>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/codebase/mmaction/mmaction.cpp b/csrc/mmdeploy/codebase/mmaction/mmaction.cpp
index 1d148e05d5..dc590a1800 100644
--- a/csrc/mmdeploy/codebase/mmaction/mmaction.cpp
+++ b/csrc/mmdeploy/codebase/mmaction/mmaction.cpp
@@ -2,12 +2,8 @@
 
 #include "mmdeploy/codebase/mmaction/mmaction.h"
 
-namespace mmdeploy {
-namespace mmaction {
+namespace mmdeploy::mmaction {
 
-REGISTER_CODEBASE(MMAction);
+MMDEPLOY_REGISTER_CODEBASE(MMAction);
 
-}
-
-MMDEPLOY_DEFINE_REGISTRY(mmaction::MMAction);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmaction
diff --git a/csrc/mmdeploy/codebase/mmaction/mmaction.h b/csrc/mmdeploy/codebase/mmaction/mmaction.h
index 253238efb2..238b780962 100644
--- a/csrc/mmdeploy/codebase/mmaction/mmaction.h
+++ b/csrc/mmdeploy/codebase/mmaction/mmaction.h
@@ -8,8 +8,7 @@
 #include "mmdeploy/core/module.h"
 #include "mmdeploy/core/serialization.h"
 
-namespace mmdeploy {
-namespace mmaction {
+namespace mmdeploy::mmaction {
 
 struct Label {
   int label_id;
@@ -19,10 +18,8 @@ struct Label {
 
 using Labels = std::vector<Label>;
 
-DECLARE_CODEBASE(MMAction, mmaction);
-}  // namespace mmaction
+MMDEPLOY_DECLARE_CODEBASE(MMAction, mmaction);
 
-MMDEPLOY_DECLARE_REGISTRY(mmaction::MMAction);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmaction
 
 #endif  // MMDEPLOY_SRC_CODEBASE_MMACTION_MMACTION_H_
diff --git a/csrc/mmdeploy/codebase/mmcls/linear_cls.cpp b/csrc/mmdeploy/codebase/mmcls/linear_cls.cpp
index 68e3eeecda..a29a9a7ffb 100644
--- a/csrc/mmdeploy/codebase/mmcls/linear_cls.cpp
+++ b/csrc/mmdeploy/codebase/mmcls/linear_cls.cpp
@@ -67,7 +67,7 @@ class LinearClsHead : public MMClassification {
   int topk_{1};
 };
 
-REGISTER_CODEBASE_COMPONENT(MMClassification, LinearClsHead);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMClassification, LinearClsHead);
 
 class CropBox {
  public:
@@ -91,12 +91,7 @@ class CropBox {
   }
 };
 
-class CropBoxCreator : public Creator<Module> {
- public:
-  const char* GetName() const override { return "CropBox"; }
-  std::unique_ptr<Module> Create(const Value& value) override { return CreateTask(CropBox{}); }
-};
-
-REGISTER_MODULE(Module, CropBoxCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Module, (CropBox, 0),
+                               [](const Value&) { return CreateTask(CropBox{}); });
 
 }  // namespace mmdeploy::mmcls
diff --git a/csrc/mmdeploy/codebase/mmcls/mmcls.cpp b/csrc/mmdeploy/codebase/mmcls/mmcls.cpp
index 69c7762426..27c11eb012 100644
--- a/csrc/mmdeploy/codebase/mmcls/mmcls.cpp
+++ b/csrc/mmdeploy/codebase/mmcls/mmcls.cpp
@@ -2,12 +2,8 @@
 
 #include "mmdeploy/codebase/mmcls/mmcls.h"
 
-namespace mmdeploy {
-namespace mmcls {
+namespace mmdeploy::mmcls {
 
-REGISTER_CODEBASE(MMClassification);
+MMDEPLOY_REGISTER_CODEBASE(MMClassification);
 
-}
-
-MMDEPLOY_DEFINE_REGISTRY(mmcls::MMClassification);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmcls
diff --git a/csrc/mmdeploy/codebase/mmcls/mmcls.h b/csrc/mmdeploy/codebase/mmcls/mmcls.h
index 3ca3dcb174..5ac3169fd9 100644
--- a/csrc/mmdeploy/codebase/mmcls/mmcls.h
+++ b/csrc/mmdeploy/codebase/mmcls/mmcls.h
@@ -8,8 +8,7 @@
 #include "mmdeploy/core/module.h"
 #include "mmdeploy/core/serialization.h"
 
-namespace mmdeploy {
-namespace mmcls {
+namespace mmdeploy::mmcls {
 
 struct Label {
   int label_id;
@@ -19,10 +18,8 @@ struct Label {
 
 using Labels = std::vector<Label>;
 
-DECLARE_CODEBASE(MMClassification, mmcls);
-}  // namespace mmcls
+MMDEPLOY_DECLARE_CODEBASE(MMClassification, mmcls);
 
-MMDEPLOY_DECLARE_REGISTRY(mmcls::MMClassification);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmcls
 
 #endif  // MMDEPLOY_SRC_CODEBASE_MMCLS_MMCLS_H_
diff --git a/csrc/mmdeploy/codebase/mmcls/multi_label_linear_cls.cpp b/csrc/mmdeploy/codebase/mmcls/multi_label_linear_cls.cpp
index e7f1e07317..e3374891e6 100644
--- a/csrc/mmdeploy/codebase/mmcls/multi_label_linear_cls.cpp
+++ b/csrc/mmdeploy/codebase/mmcls/multi_label_linear_cls.cpp
@@ -50,6 +50,6 @@ class MultiLabelLinearClsHead : public MMClassification {
   static constexpr const auto kHost = Device{0};
 };
 
-REGISTER_CODEBASE_COMPONENT(MMClassification, MultiLabelLinearClsHead);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMClassification, MultiLabelLinearClsHead);
 
 }  // namespace mmdeploy::mmcls
diff --git a/csrc/mmdeploy/codebase/mmdet/base_dense_head.cpp b/csrc/mmdeploy/codebase/mmdet/base_dense_head.cpp
index e66eacdc9b..cd2340bc87 100644
--- a/csrc/mmdeploy/codebase/mmdet/base_dense_head.cpp
+++ b/csrc/mmdeploy/codebase/mmdet/base_dense_head.cpp
@@ -98,6 +98,6 @@ Result<Detections> BaseDenseHead::GetBBoxes(const Value& prep_res, const Tensor&
   return objs;
 }
 
-REGISTER_CODEBASE_COMPONENT(MMDetection, BaseDenseHead);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMDetection, BaseDenseHead);
 
 }  // namespace mmdeploy::mmdet
diff --git a/csrc/mmdeploy/codebase/mmdet/instance_segmentation.cpp b/csrc/mmdeploy/codebase/mmdet/instance_segmentation.cpp
index 4c499c3686..c2a2b1b73b 100644
--- a/csrc/mmdeploy/codebase/mmdet/instance_segmentation.cpp
+++ b/csrc/mmdeploy/codebase/mmdet/instance_segmentation.cpp
@@ -106,6 +106,6 @@ class ResizeInstanceMask : public ResizeBBox {
   float mask_thr_binary_{.5f};
 };
 
-REGISTER_CODEBASE_COMPONENT(MMDetection, ResizeInstanceMask);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMDetection, ResizeInstanceMask);
 
 }  // namespace mmdeploy::mmdet
diff --git a/csrc/mmdeploy/codebase/mmdet/mmdet.cpp b/csrc/mmdeploy/codebase/mmdet/mmdet.cpp
index abfe16b19e..fb4e4d1f1f 100644
--- a/csrc/mmdeploy/codebase/mmdet/mmdet.cpp
+++ b/csrc/mmdeploy/codebase/mmdet/mmdet.cpp
@@ -2,12 +2,8 @@
 
 #include "mmdeploy/codebase/mmdet/mmdet.h"
 
-namespace mmdeploy {
-namespace mmdet {
+namespace mmdeploy::mmdet {
 
-REGISTER_CODEBASE(MMDetection);
+MMDEPLOY_REGISTER_CODEBASE(MMDetection);
 
-}
-
-MMDEPLOY_DEFINE_REGISTRY(mmdet::MMDetection);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmdet
diff --git a/csrc/mmdeploy/codebase/mmdet/mmdet.h b/csrc/mmdeploy/codebase/mmdet/mmdet.h
index 1228b712c2..bc02a9c1d2 100644
--- a/csrc/mmdeploy/codebase/mmdet/mmdet.h
+++ b/csrc/mmdeploy/codebase/mmdet/mmdet.h
@@ -12,8 +12,7 @@
 #include "mmdeploy/core/registry.h"
 #include "mmdeploy/core/serialization.h"
 
-namespace mmdeploy {
-namespace mmdet {
+namespace mmdeploy::mmdet {
 
 struct Detection {
   int index;
@@ -26,10 +25,8 @@ struct Detection {
 
 using Detections = std::vector<Detection>;
 
-DECLARE_CODEBASE(MMDetection, mmdet);
-}  // namespace mmdet
+MMDEPLOY_DECLARE_CODEBASE(MMDetection, mmdet);
 
-MMDEPLOY_DECLARE_REGISTRY(mmdet::MMDetection);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmdet
 
 #endif  // MMDEPLOY_SRC_CODEBASE_MMDET_MMDET_H_
diff --git a/csrc/mmdeploy/codebase/mmdet/object_detection.cpp b/csrc/mmdeploy/codebase/mmdet/object_detection.cpp
index a8cfbc4b3a..94f9b5d9fe 100644
--- a/csrc/mmdeploy/codebase/mmdet/object_detection.cpp
+++ b/csrc/mmdeploy/codebase/mmdet/object_detection.cpp
@@ -180,6 +180,6 @@ std::array<float, 4> ResizeBBox::MapToOriginImage(float left, float top, float r
   return {left, top, right, bottom};
 }
 
-REGISTER_CODEBASE_COMPONENT(MMDetection, ResizeBBox);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMDetection, ResizeBBox);
 
 }  // namespace mmdeploy::mmdet
diff --git a/csrc/mmdeploy/codebase/mmedit/mmedit.cpp b/csrc/mmdeploy/codebase/mmedit/mmedit.cpp
index 5c6d4d407a..b25317b27f 100644
--- a/csrc/mmdeploy/codebase/mmedit/mmedit.cpp
+++ b/csrc/mmdeploy/codebase/mmedit/mmedit.cpp
@@ -4,12 +4,8 @@
 
 #include "mmdeploy/core/registry.h"
 
-namespace mmdeploy {
-namespace mmedit {
+namespace mmdeploy::mmedit {
 
-REGISTER_CODEBASE(MMEdit);
+MMDEPLOY_REGISTER_CODEBASE(MMEdit);
 
-}  // namespace mmedit
-
-MMDEPLOY_DEFINE_REGISTRY(mmedit::MMEdit);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmedit
diff --git a/csrc/mmdeploy/codebase/mmedit/mmedit.h b/csrc/mmdeploy/codebase/mmedit/mmedit.h
index 122a383c22..af51c5cd2c 100644
--- a/csrc/mmdeploy/codebase/mmedit/mmedit.h
+++ b/csrc/mmdeploy/codebase/mmedit/mmedit.h
@@ -9,16 +9,12 @@
 #include "mmdeploy/core/module.h"
 #include "mmdeploy/core/serialization.h"
 
-namespace mmdeploy {
-namespace mmedit {
+namespace mmdeploy::mmedit {
 
 using RestorerOutput = Mat;
 
-DECLARE_CODEBASE(MMEdit, mmedit);
+MMDEPLOY_DECLARE_CODEBASE(MMEdit, mmedit);
 
-}  // namespace mmedit
-
-MMDEPLOY_DECLARE_REGISTRY(mmedit::MMEdit);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmedit
 
 #endif  // MMDEPLOY_SRC_CODEBASE_MMEDIT_MMEDIT_H_
diff --git a/csrc/mmdeploy/codebase/mmedit/restorer.cpp b/csrc/mmdeploy/codebase/mmedit/restorer.cpp
index e748ed7740..2b582f2425 100644
--- a/csrc/mmdeploy/codebase/mmedit/restorer.cpp
+++ b/csrc/mmdeploy/codebase/mmedit/restorer.cpp
@@ -53,6 +53,6 @@ class TensorToImg : public MMEdit {
   static constexpr const Device kHOST{0, 0};
 };
 
-REGISTER_CODEBASE_COMPONENT(MMEdit, TensorToImg);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMEdit, TensorToImg);
 
 }  // namespace mmdeploy::mmedit
diff --git a/csrc/mmdeploy/codebase/mmocr/cpu/dbnet.cpp b/csrc/mmdeploy/codebase/mmocr/cpu/dbnet.cpp
index a963c3908c..05dc494397 100644
--- a/csrc/mmdeploy/codebase/mmocr/cpu/dbnet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/cpu/dbnet.cpp
@@ -64,15 +64,7 @@ class DbHeadCpuImpl : public DbHeadImpl {
   Device device_;
 };
 
-class DbHeadCpuImplCreator : public ::mmdeploy::Creator<DbHeadImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<DbHeadImpl> Create(const Value&) override {
-    return std::make_unique<DbHeadCpuImpl>();
-  }
-};
-
-REGISTER_MODULE(DbHeadImpl, DbHeadCpuImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(DbHeadImpl, (cpu, 0),
+                               [] { return std::make_unique<DbHeadCpuImpl>(); });
 
 }  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/cpu/panet.cpp b/csrc/mmdeploy/codebase/mmocr/cpu/panet.cpp
index 8a8cf09537..cf988046be 100644
--- a/csrc/mmdeploy/codebase/mmocr/cpu/panet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/cpu/panet.cpp
@@ -49,15 +49,7 @@ class PaHeadCpuImpl : public PaHeadImpl {
   }
 };
 
-class PaHeadCpuImplCreator : public ::mmdeploy::Creator<PaHeadImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<PaHeadImpl> Create(const Value&) override {
-    return std::make_unique<PaHeadCpuImpl>();
-  }
-};
-
-REGISTER_MODULE(PaHeadImpl, PaHeadCpuImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(PaHeadImpl, (cpu, 0),
+                               [] { return std::make_unique<PaHeadCpuImpl>(); });
 
 }  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/cpu/psenet.cpp b/csrc/mmdeploy/codebase/mmocr/cpu/psenet.cpp
index fa3bbcd70e..141d7c1cbd 100644
--- a/csrc/mmdeploy/codebase/mmocr/cpu/psenet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/cpu/psenet.cpp
@@ -50,15 +50,7 @@ class PseHeadCpuImpl : public PseHeadImpl {
   Device device_;
 };
 
-class PseHeadCpuImplCreator : public ::mmdeploy::Creator<PseHeadImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<PseHeadImpl> Create(const Value&) override {
-    return std::make_unique<PseHeadCpuImpl>();
-  }
-};
-
-REGISTER_MODULE(PseHeadImpl, PseHeadCpuImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(PseHeadImpl, (cpu, 0),
+                               [] { return std::make_unique<PseHeadCpuImpl>(); });
 
 }  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/crnn.cpp b/csrc/mmdeploy/codebase/mmocr/crnn.cpp
index c9276add6b..f2696d15d6 100644
--- a/csrc/mmdeploy/codebase/mmocr/crnn.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/crnn.cpp
@@ -156,6 +156,6 @@ class CTCConvertor : public MMOCR {
   vector<string> idx2char_;
 };
 
-REGISTER_CODEBASE_COMPONENT(MMOCR, CTCConvertor);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMOCR, CTCConvertor);
 
 }  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/cuda/dbnet.cpp b/csrc/mmdeploy/codebase/mmocr/cuda/dbnet.cpp
index c91c760f9d..b14ef83962 100644
--- a/csrc/mmdeploy/codebase/mmocr/cuda/dbnet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/cuda/dbnet.cpp
@@ -73,15 +73,7 @@ class DbHeadCudaImpl : public DbHeadImpl {
   std::optional<ConnectedComponents> cc_;
 };
 
-class DbHeadCudaImplCreator : public ::mmdeploy::Creator<DbHeadImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<DbHeadImpl> Create(const Value&) override {
-    return std::make_unique<DbHeadCudaImpl>();
-  }
-};
-
-REGISTER_MODULE(DbHeadImpl, DbHeadCudaImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(DbHeadImpl, (cuda, 0),
+                               [] { return std::make_unique<DbHeadCudaImpl>(); });
 
 }  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/cuda/panet.cpp b/csrc/mmdeploy/codebase/mmocr/cuda/panet.cpp
index 100808bcf4..3dcfec9411 100644
--- a/csrc/mmdeploy/codebase/mmocr/cuda/panet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/cuda/panet.cpp
@@ -96,15 +96,7 @@ class PaHeadCudaImpl : public PaHeadImpl {
   std::optional<ConnectedComponents> cc_;
 };
 
-class PaHeadCudaImplCreator : public ::mmdeploy::Creator<PaHeadImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<PaHeadImpl> Create(const Value&) override {
-    return std::make_unique<PaHeadCudaImpl>();
-  }
-};
-
-REGISTER_MODULE(PaHeadImpl, PaHeadCudaImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(PaHeadImpl, (cuda, 0),
+                               [] { return std::make_unique<PaHeadCudaImpl>(); });
 
 }  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/cuda/psenet.cpp b/csrc/mmdeploy/codebase/mmocr/cuda/psenet.cpp
index 33a94d2f8b..6432c13247 100644
--- a/csrc/mmdeploy/codebase/mmocr/cuda/psenet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/cuda/psenet.cpp
@@ -71,15 +71,7 @@ class PseHeadCudaImpl : public PseHeadImpl {
   std::optional<ConnectedComponents> cc_;
 };
 
-class PseHeadCudaImplCreator : public ::mmdeploy::Creator<PseHeadImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<PseHeadImpl> Create(const Value&) override {
-    return std::make_unique<PseHeadCudaImpl>();
-  }
-};
-
-REGISTER_MODULE(PseHeadImpl, PseHeadCudaImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(PseHeadImpl, (cuda, 0),
+                               [] { return std::make_unique<PseHeadCudaImpl>(); });
 
 }  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/dbnet.cpp b/csrc/mmdeploy/codebase/mmocr/dbnet.cpp
index b4f4d4ee69..be0716a05d 100644
--- a/csrc/mmdeploy/codebase/mmocr/dbnet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/dbnet.cpp
@@ -11,9 +11,7 @@
 #include "mmdeploy/experimental/module_adapter.h"
 #include "mmocr.h"
 
-namespace mmdeploy {
-
-namespace mmocr {
+namespace mmdeploy::mmocr {
 
 using std::string;
 using std::vector;
@@ -33,14 +31,14 @@ class DBHead : public MMOCR {
       downsample_ratio_ = params.value("downsample_ratio", downsample_ratio_);
     }
     auto platform = Platform(device_.platform_id()).GetPlatformName();
-    auto creator = Registry<DbHeadImpl>::Get().GetCreator(platform);
+    auto creator = gRegistry<DbHeadImpl>().Get(platform);
     if (!creator) {
       MMDEPLOY_ERROR(
           "DBHead: implementation for platform \"{}\" not found. Available platforms: {}", platform,
-          Registry<DbHeadImpl>::Get().List());
+          gRegistry<DbHeadImpl>().List());
       throw_exception(eEntryNotFound);
     }
-    impl_ = creator->Create(nullptr);
+    impl_ = creator->Create();
     impl_->Init(stream_);
   }
 
@@ -130,10 +128,8 @@ class DBHead : public MMOCR {
   std::unique_ptr<DbHeadImpl> impl_;
 };
 
-REGISTER_CODEBASE_COMPONENT(MMOCR, DBHead);
-
-}  // namespace mmocr
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMOCR, DBHead);
 
-MMDEPLOY_DEFINE_REGISTRY(mmocr::DbHeadImpl);
+MMDEPLOY_DEFINE_REGISTRY(DbHeadImpl);
 
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/dbnet.h b/csrc/mmdeploy/codebase/mmocr/dbnet.h
index e1a437354c..c7510c7760 100644
--- a/csrc/mmdeploy/codebase/mmocr/dbnet.h
+++ b/csrc/mmdeploy/codebase/mmocr/dbnet.h
@@ -9,8 +9,7 @@
 #include "mmdeploy/core/tensor.h"
 #include "opencv2/core.hpp"
 
-namespace mmdeploy {
-namespace mmocr {
+namespace mmdeploy::mmocr {
 
 class DbHeadImpl {
  public:
@@ -26,10 +25,8 @@ class DbHeadImpl {
   Stream stream_;
 };
 
-}  // namespace mmocr
+MMDEPLOY_DECLARE_REGISTRY(DbHeadImpl, std::unique_ptr<DbHeadImpl>());
 
-MMDEPLOY_DECLARE_REGISTRY(mmocr::DbHeadImpl);
-
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
 
 #endif  // MMDEPLOY_CSRC_CODEBASE_MMOCR_DBNET_H_
diff --git a/csrc/mmdeploy/codebase/mmocr/mmocr.cpp b/csrc/mmdeploy/codebase/mmocr/mmocr.cpp
index 2aeef1fda9..1654ddd929 100644
--- a/csrc/mmdeploy/codebase/mmocr/mmocr.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/mmocr.cpp
@@ -5,12 +5,8 @@
 #include "mmdeploy/core/registry.h"
 #include "mmdeploy/core/utils/formatter.h"
 
-namespace mmdeploy {
-namespace mmocr {
+namespace mmdeploy::mmocr {
 
-REGISTER_CODEBASE(MMOCR);
+MMDEPLOY_REGISTER_CODEBASE(MMOCR);
 
-}  // namespace mmocr
-
-MMDEPLOY_DEFINE_REGISTRY(mmocr::MMOCR);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/mmocr.h b/csrc/mmdeploy/codebase/mmocr/mmocr.h
index 3fc1869978..f8c67a4036 100644
--- a/csrc/mmdeploy/codebase/mmocr/mmocr.h
+++ b/csrc/mmdeploy/codebase/mmocr/mmocr.h
@@ -9,8 +9,7 @@
 #include "mmdeploy/core/device.h"
 #include "mmdeploy/core/module.h"
 
-namespace mmdeploy {
-namespace mmocr {
+namespace mmdeploy::mmocr {
 
 struct TextDetection {
   std::array<float, 8> bbox;
@@ -26,11 +25,8 @@ struct TextRecognition {
   MMDEPLOY_ARCHIVE_MEMBERS(text, score);
 };
 
-DECLARE_CODEBASE(MMOCR, mmocr);
+MMDEPLOY_DECLARE_CODEBASE(MMOCR, mmocr);
 
-}  // namespace mmocr
-
-MMDEPLOY_DECLARE_REGISTRY(mmocr::MMOCR);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
 
 #endif  // MMDEPLOY_MMOCR_H
diff --git a/csrc/mmdeploy/codebase/mmocr/panet.cpp b/csrc/mmdeploy/codebase/mmocr/panet.cpp
index 651cd476d4..b00d7b736a 100644
--- a/csrc/mmdeploy/codebase/mmocr/panet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/panet.cpp
@@ -11,9 +11,7 @@
 #include "mmdeploy/core/utils/device_utils.h"
 #include "opencv2/imgproc/imgproc.hpp"
 
-namespace mmdeploy {
-
-namespace mmocr {
+namespace mmdeploy::mmocr {
 
 std::vector<std::vector<float>> pixel_group_cpu(const cv::Mat_<float>& score,
                                                 const cv::Mat_<uint8_t>& mask,
@@ -35,14 +33,14 @@ class PANHead : public MMOCR {
       downsample_ratio_ = params.value("downsample_ratio", downsample_ratio_);
     }
     auto platform = Platform(device_.platform_id()).GetPlatformName();
-    auto creator = Registry<PaHeadImpl>::Get().GetCreator(platform);
+    auto creator = gRegistry<PaHeadImpl>().Get(platform);
     if (!creator) {
       MMDEPLOY_ERROR(
           "PANHead: implementation for platform \"{}\" not found. Available platforms: {}",
-          platform, Registry<PaHeadImpl>::Get().List());
+          platform, gRegistry<PaHeadImpl>().List());
       throw_exception(eEntryNotFound);
     }
-    impl_ = creator->Create(nullptr);
+    impl_ = creator->Create();
     impl_->Init(stream_);
   }
 
@@ -121,10 +119,8 @@ class PANHead : public MMOCR {
   std::unique_ptr<PaHeadImpl> impl_;
 };
 
-REGISTER_CODEBASE_COMPONENT(MMOCR, PANHead);
-
-}  // namespace mmocr
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMOCR, PANHead);
 
-MMDEPLOY_DEFINE_REGISTRY(mmocr::PaHeadImpl);
+MMDEPLOY_DEFINE_REGISTRY(PaHeadImpl);
 
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/panet.h b/csrc/mmdeploy/codebase/mmocr/panet.h
index 07ee4e81f1..32a5cd638c 100644
--- a/csrc/mmdeploy/codebase/mmocr/panet.h
+++ b/csrc/mmdeploy/codebase/mmocr/panet.h
@@ -9,8 +9,7 @@
 #include "mmdeploy/core/tensor.h"
 #include "opencv2/core.hpp"
 
-namespace mmdeploy {
-namespace mmocr {
+namespace mmdeploy::mmocr {
 
 class PaHeadImpl {
  public:
@@ -34,10 +33,8 @@ class PaHeadImpl {
   Stream stream_;
 };
 
-}  // namespace mmocr
+MMDEPLOY_DECLARE_REGISTRY(PaHeadImpl, std::unique_ptr<PaHeadImpl>());
 
-MMDEPLOY_DECLARE_REGISTRY(mmocr::PaHeadImpl);
-
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
 
 #endif  // MMDEPLOY_CSRC_CODEBASE_MMOCR_PANET_H_
diff --git a/csrc/mmdeploy/codebase/mmocr/psenet.cpp b/csrc/mmdeploy/codebase/mmocr/psenet.cpp
index 2e2b97b9ae..ad66c675fe 100644
--- a/csrc/mmdeploy/codebase/mmocr/psenet.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/psenet.cpp
@@ -11,8 +11,7 @@
 #include "mmdeploy/core/utils/device_utils.h"
 #include "opencv2/imgproc/imgproc.hpp"
 
-namespace mmdeploy {
-namespace mmocr {
+namespace mmdeploy::mmocr {
 
 void contour_expand(const cv::Mat_<uint8_t>& kernel_masks, const cv::Mat_<int32_t>& kernel_label,
                     const cv::Mat_<float>& score, int min_kernel_area, int kernel_num,
@@ -32,14 +31,14 @@ class PSEHead : public MMOCR {
       downsample_ratio_ = params.value("downsample_ratio", downsample_ratio_);
     }
     auto platform = Platform(device_.platform_id()).GetPlatformName();
-    auto creator = Registry<PseHeadImpl>::Get().GetCreator(platform);
+    auto creator = gRegistry<PseHeadImpl>().Get(platform);
     if (!creator) {
       MMDEPLOY_ERROR(
           "PSEHead: implementation for platform \"{}\" not found. Available platforms: {}",
-          platform, Registry<PseHeadImpl>::Get().List());
+          platform, gRegistry<PseHeadImpl>().List());
       throw_exception(eEntryNotFound);
     }
-    impl_ = creator->Create(nullptr);
+    impl_ = creator->Create();
     impl_->Init(stream_);
   }
 
@@ -118,10 +117,8 @@ class PSEHead : public MMOCR {
   std::unique_ptr<PseHeadImpl> impl_;
 };
 
-REGISTER_CODEBASE_COMPONENT(MMOCR, PSEHead);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMOCR, PSEHead);
 
-}  // namespace mmocr
+MMDEPLOY_DEFINE_REGISTRY(PseHeadImpl);
 
-MMDEPLOY_DEFINE_REGISTRY(mmocr::PseHeadImpl);
-
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/psenet.h b/csrc/mmdeploy/codebase/mmocr/psenet.h
index 4fafc26a53..cec376fdc2 100644
--- a/csrc/mmdeploy/codebase/mmocr/psenet.h
+++ b/csrc/mmdeploy/codebase/mmocr/psenet.h
@@ -9,8 +9,7 @@
 #include "mmdeploy/core/tensor.h"
 #include "opencv2/core.hpp"
 
-namespace mmdeploy {
-namespace mmocr {
+namespace mmdeploy::mmocr {
 
 class PseHeadImpl {
  public:
@@ -29,10 +28,8 @@ class PseHeadImpl {
   Stream stream_;
 };
 
-}  // namespace mmocr
+MMDEPLOY_DECLARE_REGISTRY(PseHeadImpl, std::unique_ptr<PseHeadImpl>());
 
-MMDEPLOY_DECLARE_REGISTRY(mmocr::PseHeadImpl);
-
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
 
 #endif  // MMDEPLOY_CSRC_CODEBASE_MMOCR_PSENET_H_
diff --git a/csrc/mmdeploy/codebase/mmocr/rescale_to_height.cpp b/csrc/mmdeploy/codebase/mmocr/rescale_to_height.cpp
index d965e58f0d..0f6e5796de 100644
--- a/csrc/mmdeploy/codebase/mmocr/rescale_to_height.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/rescale_to_height.cpp
@@ -112,18 +112,14 @@ class RescaleToHeightImpl : public Module {
   Stream stream_;
 };
 
-class RescaleToHeightImplCreator : public Creator<RescaleToHeightImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<RescaleToHeightImpl>(args);
-  }
-};
+MMDEPLOY_CREATOR_SIGNATURE(RescaleToHeightImpl,
+                           std::unique_ptr<RescaleToHeightImpl>(const Value& config));
 
 MMDEPLOY_DEFINE_REGISTRY(RescaleToHeightImpl);
 
-REGISTER_MODULE(RescaleToHeightImpl, RescaleToHeightImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(RescaleToHeightImpl, (cpu, 0), [](const Value& config) {
+  return std::make_unique<RescaleToHeightImpl>(config);
+});
 
 class RescaleToHeight : public Transform {
  public:
@@ -139,5 +135,8 @@ class RescaleToHeight : public Transform {
   static const std::string name_;
 };
 
-DECLARE_AND_REGISTER_MODULE(Transform, RescaleToHeight, 1);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (ResizeOCR, 0), [](const Value& config) {
+  return std::make_unique<RescaleToHeight>(config);
+});
+
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/codebase/mmocr/resize_ocr.cpp b/csrc/mmdeploy/codebase/mmocr/resize_ocr.cpp
index 85420e7ed9..e1cd3f435a 100644
--- a/csrc/mmdeploy/codebase/mmocr/resize_ocr.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/resize_ocr.cpp
@@ -15,7 +15,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
+namespace mmdeploy::mmocr {
 
 class ResizeOCRImpl : public Module {
  public:
@@ -130,16 +130,13 @@ class ResizeOCRImpl : public Module {
   Stream stream_;
 };
 
-class ResizeOCRImplCreator : public Creator<ResizeOCRImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return std::make_unique<ResizeOCRImpl>(args); }
-};
+MMDEPLOY_CREATOR_SIGNATURE(ResizeOCRImpl, std::unique_ptr<ResizeOCRImpl>(const Value& config));
 
 MMDEPLOY_DEFINE_REGISTRY(ResizeOCRImpl);
 
-REGISTER_MODULE(ResizeOCRImpl, ResizeOCRImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(ResizeOCRImpl, (cpu, 0), [](const Value& config) {
+  return std::make_unique<ResizeOCRImpl>(config);
+});
 
 class ResizeOCR : public Transform {
  public:
@@ -155,5 +152,8 @@ class ResizeOCR : public Transform {
   static const std::string name_;
 };
 
-DECLARE_AND_REGISTER_MODULE(Transform, ResizeOCR, 1);
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (ResizeOCR, 0), [](const Value& config) {
+  return std::make_unique<ResizeOCR>(config);
+});
+
+}  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmocr/short_scale_aspect_jitter.cpp b/csrc/mmdeploy/codebase/mmocr/short_scale_aspect_jitter.cpp
index 53e22337c0..02c98613ab 100644
--- a/csrc/mmdeploy/codebase/mmocr/short_scale_aspect_jitter.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/short_scale_aspect_jitter.cpp
@@ -27,14 +27,16 @@ class ShortScaleAspectJitterImpl : public Module {
       ratio_range_[0] = args["ratio_range"][0].get<float>();
       ratio_range_[1] = args["ratio_range"][1].get<float>();
     } else {
-      throw std::invalid_argument("'ratio_range' should be a float array of size 2");
+      MMDEPLOY_ERROR("'ratio_range' should be a float array of size 2");
+      throw_exception(eInvalidArgument);
     }
 
     if (args["aspect_ratio_range"].is_array() && args["aspect_ratio_range"].size() == 2) {
       aspect_ratio_range_[0] = args["aspect_ratio_range"][0].get<float>();
       aspect_ratio_range_[1] = args["aspect_ratio_range"][1].get<float>();
     } else {
-      throw std::invalid_argument("'aspect_ratio_range' should be a float array of size 2");
+      MMDEPLOY_ERROR("'aspect_ratio_range' should be a float array of size 2");
+      throw_exception(eInvalidArgument);
     }
     scale_divisor_ = args.contains("scale_divisor") && args["scale_divisor"].is_number_integer()
                          ? args["scale_divisor"].get<int>()
@@ -120,18 +122,13 @@ class ShortScaleAspectJitterImpl : public Module {
   Stream stream_;
 };
 
-class ShortScaleAspectJitterImplCreator : public Creator<ShortScaleAspectJitterImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<ShortScaleAspectJitterImpl>(args);
-  }
-};
-
+MMDEPLOY_CREATOR_SIGNATURE(ShortScaleAspectJitterImpl,
+                           std::unique_ptr<ShortScaleAspectJitterImpl>(const Value& config));
 MMDEPLOY_DEFINE_REGISTRY(ShortScaleAspectJitterImpl);
 
-REGISTER_MODULE(ShortScaleAspectJitterImpl, ShortScaleAspectJitterImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(ShortScaleAspectJitterImpl, (cpu, 0), [](const Value& config) {
+  return std::make_unique<ShortScaleAspectJitterImpl>(config);
+});
 
 class ShortScaleAspectJitter : public Transform {
  public:
@@ -147,5 +144,8 @@ class ShortScaleAspectJitter : public Transform {
   static const std::string name_;
 };
 
-DECLARE_AND_REGISTER_MODULE(Transform, ShortScaleAspectJitter, 1);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (ShortScaleAspectJitter, 0), [](const Value& config) {
+  return std::make_unique<ShortScaleAspectJitter>(config);
+});
+
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/codebase/mmocr/warp.cpp b/csrc/mmdeploy/codebase/mmocr/warp.cpp
index fd8300d0f6..9173435366 100644
--- a/csrc/mmdeploy/codebase/mmocr/warp.cpp
+++ b/csrc/mmdeploy/codebase/mmocr/warp.cpp
@@ -11,7 +11,7 @@
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv_utils.h"
 
-namespace mmdeploy {
+namespace mmdeploy::mmocr {
 
 // Warp rotated rect
 class WarpBbox {
@@ -64,12 +64,7 @@ class WarpBbox {
   }
 };
 
-class WarpBboxCreator : public Creator<Module> {
- public:
-  const char* GetName() const override { return "WarpBbox"; }
-  std::unique_ptr<Module> Create(const Value& value) override { return CreateTask(WarpBbox{}); }
-};
-
-REGISTER_MODULE(Module, WarpBboxCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Module, (WarpBbox, 0),
+                               [](const Value&) { return CreateTask(WarpBbox{}); });
 
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmocr
diff --git a/csrc/mmdeploy/codebase/mmpose/keypoints_from_heatmap.cpp b/csrc/mmdeploy/codebase/mmpose/keypoints_from_heatmap.cpp
index 81df42adb6..cf20173e69 100644
--- a/csrc/mmdeploy/codebase/mmpose/keypoints_from_heatmap.cpp
+++ b/csrc/mmdeploy/codebase/mmpose/keypoints_from_heatmap.cpp
@@ -374,16 +374,16 @@ class TopdownHeatmapBaseHeadDecode : public MMPose {
   string target_type_{"GaussianHeatmap"};
 };
 
-REGISTER_CODEBASE_COMPONENT(MMPose, TopdownHeatmapBaseHeadDecode);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMPose, TopdownHeatmapBaseHeadDecode);
 
 // decode process is same
 using TopdownHeatmapSimpleHeadDecode = TopdownHeatmapBaseHeadDecode;
-REGISTER_CODEBASE_COMPONENT(MMPose, TopdownHeatmapSimpleHeadDecode);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMPose, TopdownHeatmapSimpleHeadDecode);
 using TopdownHeatmapMultiStageHeadDecode = TopdownHeatmapBaseHeadDecode;
-REGISTER_CODEBASE_COMPONENT(MMPose, TopdownHeatmapMultiStageHeadDecode);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMPose, TopdownHeatmapMultiStageHeadDecode);
 using ViPNASHeatmapSimpleHeadDecode = TopdownHeatmapBaseHeadDecode;
-REGISTER_CODEBASE_COMPONENT(MMPose, ViPNASHeatmapSimpleHeadDecode);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMPose, ViPNASHeatmapSimpleHeadDecode);
 using TopdownHeatmapMSMUHeadDecode = TopdownHeatmapBaseHeadDecode;
-REGISTER_CODEBASE_COMPONENT(MMPose, TopdownHeatmapMSMUHeadDecode);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMPose, TopdownHeatmapMSMUHeadDecode);
 
 }  // namespace mmdeploy::mmpose
diff --git a/csrc/mmdeploy/codebase/mmpose/keypoints_from_regression.cpp b/csrc/mmdeploy/codebase/mmpose/keypoints_from_regression.cpp
index 6104be047a..6810519575 100644
--- a/csrc/mmdeploy/codebase/mmpose/keypoints_from_regression.cpp
+++ b/csrc/mmdeploy/codebase/mmpose/keypoints_from_regression.cpp
@@ -109,6 +109,6 @@ class DeepposeRegressionHeadDecode : public MMPose {
   }
 };
 
-REGISTER_CODEBASE_COMPONENT(MMPose, DeepposeRegressionHeadDecode);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMPose, DeepposeRegressionHeadDecode);
 
 }  // namespace mmdeploy::mmpose
diff --git a/csrc/mmdeploy/codebase/mmpose/mmpose.cpp b/csrc/mmdeploy/codebase/mmpose/mmpose.cpp
index 0102ce1b19..6b2940b9f9 100644
--- a/csrc/mmdeploy/codebase/mmpose/mmpose.cpp
+++ b/csrc/mmdeploy/codebase/mmpose/mmpose.cpp
@@ -2,14 +2,8 @@
 
 #include "mmdeploy/codebase/mmpose/mmpose.h"
 
-using namespace std;
+namespace mmdeploy::mmpose {
 
-namespace mmdeploy {
-namespace mmpose {
+MMDEPLOY_REGISTER_CODEBASE(MMPose);
 
-REGISTER_CODEBASE(MMPose);
-
-}
-
-MMDEPLOY_DEFINE_REGISTRY(mmpose::MMPose);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmpose
diff --git a/csrc/mmdeploy/codebase/mmpose/mmpose.h b/csrc/mmdeploy/codebase/mmpose/mmpose.h
index 0c08db7832..3da9a9332a 100644
--- a/csrc/mmdeploy/codebase/mmpose/mmpose.h
+++ b/csrc/mmdeploy/codebase/mmpose/mmpose.h
@@ -9,8 +9,7 @@
 #include "mmdeploy/core/device.h"
 #include "mmdeploy/core/module.h"
 
-namespace mmdeploy {
-namespace mmpose {
+namespace mmdeploy::mmpose {
 
 struct PoseDetectorOutput {
   struct KeyPoint {
@@ -22,11 +21,8 @@ struct PoseDetectorOutput {
   MMDEPLOY_ARCHIVE_MEMBERS(key_points);
 };
 
-DECLARE_CODEBASE(MMPose, mmpose);
+MMDEPLOY_DECLARE_CODEBASE(MMPose, mmpose);
 
-}  // namespace mmpose
-
-MMDEPLOY_DECLARE_REGISTRY(mmpose::MMPose);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmpose
 
 #endif  // MMDEPLOY_MMPOSE_H
diff --git a/csrc/mmdeploy/codebase/mmpose/simcc_label.cpp b/csrc/mmdeploy/codebase/mmpose/simcc_label.cpp
index ce38c056d3..8efbf98017 100644
--- a/csrc/mmdeploy/codebase/mmpose/simcc_label.cpp
+++ b/csrc/mmdeploy/codebase/mmpose/simcc_label.cpp
@@ -118,6 +118,6 @@ class SimCCLabelDecode : public MMPose {
   std::vector<int> input_size_{192, 256};
 };
 
-REGISTER_CODEBASE_COMPONENT(MMPose, SimCCLabelDecode);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMPose, SimCCLabelDecode);
 
 }  // namespace mmdeploy::mmpose
diff --git a/csrc/mmdeploy/codebase/mmpose/topdown_affine.cpp b/csrc/mmdeploy/codebase/mmpose/topdown_affine.cpp
index b63dec4d65..089988b749 100644
--- a/csrc/mmdeploy/codebase/mmpose/topdown_affine.cpp
+++ b/csrc/mmdeploy/codebase/mmpose/topdown_affine.cpp
@@ -169,18 +169,14 @@ class TopDownAffineImpl : public Module {
   Stream stream_;
 };
 
-class TopDownAffineImplCreator : public Creator<TopDownAffineImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<TopDownAffineImpl>(args);
-  }
-};
+MMDEPLOY_CREATOR_SIGNATURE(TopDownAffineImpl,
+                           std::unique_ptr<TopDownAffineImpl>(const Value& config));
 
 MMDEPLOY_DEFINE_REGISTRY(TopDownAffineImpl);
 
-REGISTER_MODULE(TopDownAffineImpl, TopDownAffineImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(TopDownAffineImpl, (cpu, 0), [](const Value& config) {
+  return std::make_unique<TopDownAffineImpl>(config);
+});
 
 class TopDownAffine : public Transform {
  public:
@@ -196,6 +192,8 @@ class TopDownAffine : public Transform {
   static const std::string name_;
 };
 
-DECLARE_AND_REGISTER_MODULE(Transform, TopDownAffine, 1);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (TopDownAffine, 0), [](const Value& config) {
+  return std::make_unique<TopDownAffine>(config);
+});
 
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/codebase/mmpose/topdown_get_bbox_center_scale.cpp b/csrc/mmdeploy/codebase/mmpose/topdown_get_bbox_center_scale.cpp
index 3d00385bbd..b921b4b033 100644
--- a/csrc/mmdeploy/codebase/mmpose/topdown_get_bbox_center_scale.cpp
+++ b/csrc/mmdeploy/codebase/mmpose/topdown_get_bbox_center_scale.cpp
@@ -68,23 +68,19 @@ class TopDownGetBboxCenterScaleImpl : public TransformImpl {
   vector<int> image_size_;
 };
 
-class TopDownGetBboxCenterScaleImplCreator : public Creator<TopDownGetBboxCenterScaleImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<TopDownGetBboxCenterScaleImpl>(args);
-  }
-};
+MMDEPLOY_CREATOR_SIGNATURE(TopDownGetBboxCenterScaleImpl,
+                           std::unique_ptr<TopDownGetBboxCenterScaleImpl>(const Value& config));
 
 MMDEPLOY_DEFINE_REGISTRY(TopDownGetBboxCenterScaleImpl);
 
-REGISTER_MODULE(TopDownGetBboxCenterScaleImpl, TopDownGetBboxCenterScaleImplCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(TopDownGetBboxCenterScaleImpl, (cpu, 0), [](const Value& config) {
+  return std::make_unique<TopDownGetBboxCenterScaleImpl>(config);
+});
 
 class TopDownGetBboxCenterScale : public Transform {
  public:
   explicit TopDownGetBboxCenterScale(const Value& args) : Transform(args) {
-    auto impl_creator = Registry<TopDownGetBboxCenterScaleImpl>::Get().GetCreator("cpu", 1);
+    auto impl_creator = gRegistry<TopDownGetBboxCenterScaleImpl>().Get("cpu");
     impl_ = impl_creator->Create(args);
   }
   ~TopDownGetBboxCenterScale() override = default;
@@ -96,6 +92,8 @@ class TopDownGetBboxCenterScale : public Transform {
   static const std::string name_;
 };
 
-DECLARE_AND_REGISTER_MODULE(Transform, TopDownGetBboxCenterScale, 1);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (TopDownGetBboxCenterScale, 0), [](const Value& config) {
+  return std::make_unique<TopDownGetBboxCenterScale>(config);
+});
 
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/codebase/mmrotate/mmrotate.cpp b/csrc/mmdeploy/codebase/mmrotate/mmrotate.cpp
index 566d660549..ee22f35f99 100644
--- a/csrc/mmdeploy/codebase/mmrotate/mmrotate.cpp
+++ b/csrc/mmdeploy/codebase/mmrotate/mmrotate.cpp
@@ -2,14 +2,8 @@
 
 #include "mmdeploy/codebase/mmrotate/mmrotate.h"
 
-using namespace std;
+namespace mmdeploy::mmrotate {
 
-namespace mmdeploy {
-namespace mmrotate {
+MMDEPLOY_REGISTER_CODEBASE(MMRotate);
 
-REGISTER_CODEBASE(MMRotate);
-
-}  // namespace mmrotate
-
-MMDEPLOY_DEFINE_REGISTRY(mmrotate::MMRotate);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmrotate
diff --git a/csrc/mmdeploy/codebase/mmrotate/mmrotate.h b/csrc/mmdeploy/codebase/mmrotate/mmrotate.h
index 17dbde508f..83fc5bdc0f 100644
--- a/csrc/mmdeploy/codebase/mmrotate/mmrotate.h
+++ b/csrc/mmdeploy/codebase/mmrotate/mmrotate.h
@@ -9,8 +9,7 @@
 #include "mmdeploy/core/device.h"
 #include "mmdeploy/core/module.h"
 
-namespace mmdeploy {
-namespace mmrotate {
+namespace mmdeploy::mmrotate {
 
 struct RotatedDetectorOutput {
   struct Detection {
@@ -23,10 +22,8 @@ struct RotatedDetectorOutput {
   MMDEPLOY_ARCHIVE_MEMBERS(detections);
 };
 
-DECLARE_CODEBASE(MMRotate, mmrotate);
-}  // namespace mmrotate
+MMDEPLOY_DECLARE_CODEBASE(MMRotate, mmrotate);
 
-MMDEPLOY_DECLARE_REGISTRY(mmrotate::MMRotate);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmrotate
 
 #endif  // MMDEPLOY_MMROTATE_H
diff --git a/csrc/mmdeploy/codebase/mmrotate/oriented_object_detection.cpp b/csrc/mmdeploy/codebase/mmrotate/oriented_object_detection.cpp
index 161d91a088..c5d8f8a38f 100644
--- a/csrc/mmdeploy/codebase/mmrotate/oriented_object_detection.cpp
+++ b/csrc/mmdeploy/codebase/mmrotate/oriented_object_detection.cpp
@@ -108,6 +108,6 @@ class ResizeRBBox : public MMRotate {
   float score_thr_;
 };
 
-REGISTER_CODEBASE_COMPONENT(MMRotate, ResizeRBBox);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMRotate, ResizeRBBox);
 
 }  // namespace mmdeploy::mmrotate
diff --git a/csrc/mmdeploy/codebase/mmseg/mmseg.cpp b/csrc/mmdeploy/codebase/mmseg/mmseg.cpp
index 0da46a862f..36d0add8eb 100644
--- a/csrc/mmdeploy/codebase/mmseg/mmseg.cpp
+++ b/csrc/mmdeploy/codebase/mmseg/mmseg.cpp
@@ -2,14 +2,8 @@
 
 #include "mmdeploy/codebase/mmseg/mmseg.h"
 
-using namespace std;
+namespace mmdeploy::mmseg {
 
-namespace mmdeploy {
-namespace mmseg {
+MMDEPLOY_REGISTER_CODEBASE(MMSegmentation);
 
-REGISTER_CODEBASE(MMSegmentation);
-
-}
-
-MMDEPLOY_DEFINE_REGISTRY(mmseg::MMSegmentation);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmseg
diff --git a/csrc/mmdeploy/codebase/mmseg/mmseg.h b/csrc/mmdeploy/codebase/mmseg/mmseg.h
index cccf35222d..8a9c0f6d78 100644
--- a/csrc/mmdeploy/codebase/mmseg/mmseg.h
+++ b/csrc/mmdeploy/codebase/mmseg/mmseg.h
@@ -8,8 +8,7 @@
 #include "mmdeploy/core/module.h"
 #include "mmdeploy/core/tensor.h"
 
-namespace mmdeploy {
-namespace mmseg {
+namespace mmdeploy::mmseg {
 
 struct SegmentorOutput {
   Tensor mask;
@@ -19,11 +18,8 @@ struct SegmentorOutput {
   MMDEPLOY_ARCHIVE_MEMBERS(mask, height, width, classes);
 };
 
-DECLARE_CODEBASE(MMSegmentation, mmseg);
+MMDEPLOY_DECLARE_CODEBASE(MMSegmentation, mmseg);
 
-}  // namespace mmseg
-
-MMDEPLOY_DECLARE_REGISTRY(mmseg::MMSegmentation);
-}  // namespace mmdeploy
+}  // namespace mmdeploy::mmseg
 
 #endif  // MMDEPLOY_MMSEG_H
diff --git a/csrc/mmdeploy/codebase/mmseg/segment.cpp b/csrc/mmdeploy/codebase/mmseg/segment.cpp
index a9c4bb3591..b1128886c2 100644
--- a/csrc/mmdeploy/codebase/mmseg/segment.cpp
+++ b/csrc/mmdeploy/codebase/mmseg/segment.cpp
@@ -88,6 +88,6 @@ class ResizeMask : public MMSegmentation {
   bool little_endian_;
 };
 
-REGISTER_CODEBASE_COMPONENT(MMSegmentation, ResizeMask);
+MMDEPLOY_REGISTER_CODEBASE_COMPONENT(MMSegmentation, ResizeMask);
 
 }  // namespace mmdeploy::mmseg
diff --git a/csrc/mmdeploy/core/graph.cpp b/csrc/mmdeploy/core/graph.cpp
index 8efe486159..d83e45b97d 100644
--- a/csrc/mmdeploy/core/graph.cpp
+++ b/csrc/mmdeploy/core/graph.cpp
@@ -7,8 +7,7 @@
 #include "mmdeploy/graph/common.h"
 #include "mmdeploy/graph/flattened.h"
 
-namespace mmdeploy {
-namespace graph {
+namespace mmdeploy::graph {
 
 namespace {
 
@@ -106,7 +105,7 @@ Result<unique_ptr<Builder>> Builder::CreateFromConfig(const Value& config) {
       }
     }
   }
-  auto creator = Registry<Builder>::Get().GetCreator(type);
+  auto creator = gRegistry<Builder>().Get(type);
   if (!creator) {
     MMDEPLOY_ERROR("failed to find node creator: {}", type);
     return Status(eEntryNotFound);
@@ -128,8 +127,6 @@ Result<std::vector<std::string>> ParseStringArray(const Value& value) {
   return Status(eInvalidArgument);
 }
 
-}  // namespace graph
+MMDEPLOY_DEFINE_REGISTRY(Builder);
 
-MMDEPLOY_DEFINE_REGISTRY(graph::Builder);
-
-}  // namespace mmdeploy
+}  // namespace mmdeploy::graph
diff --git a/csrc/mmdeploy/core/graph.h b/csrc/mmdeploy/core/graph.h
index 3993035048..2cb623529b 100644
--- a/csrc/mmdeploy/core/graph.h
+++ b/csrc/mmdeploy/core/graph.h
@@ -11,9 +11,7 @@
 #include "mmdeploy/core/utils/formatter.h"
 #include "mmdeploy/execution/schedulers/registry.h"
 
-namespace mmdeploy {
-
-namespace graph {
+namespace mmdeploy::graph {
 
 using std::pair;
 using std::string;
@@ -68,10 +66,8 @@ class MMDEPLOY_API Builder {
 
 MMDEPLOY_API Result<std::vector<std::string>> ParseStringArray(const Value& value);
 
-}  // namespace graph
-
-MMDEPLOY_DECLARE_REGISTRY(graph::Builder);
+MMDEPLOY_DECLARE_REGISTRY(Builder, std::unique_ptr<Builder>(const Value& config));
 
-}  // namespace mmdeploy
+}  // namespace mmdeploy::graph
 
 #endif  // MMDEPLOY_SRC_EXPERIMENTAL_PIPELINE_IR_H_
diff --git a/csrc/mmdeploy/core/macro.h b/csrc/mmdeploy/core/macro.h
index 6f52f0b5fa..8d3ebdb345 100644
--- a/csrc/mmdeploy/core/macro.h
+++ b/csrc/mmdeploy/core/macro.h
@@ -22,6 +22,8 @@
 #define _MMDEPLOY_PP_CONCAT_IMPL(s1, s2) s1##s2
 #define MMDEPLOY_PP_CONCAT(s1, s2) _MMDEPLOY_PP_CONCAT_IMPL(s1, s2)
 
+#define MMDEPLOY_PP_EXPAND(...) __VA_ARGS__
+
 // ! Be aware of ODR violation when using __COUNTER__
 #ifdef __COUNTER__
 #define MMDEPLOY_ANONYMOUS_VARIABLE(str) MMDEPLOY_PP_CONCAT(str, __COUNTER__)
diff --git a/csrc/mmdeploy/core/model.cpp b/csrc/mmdeploy/core/model.cpp
index 5227dad117..17688e6ecd 100644
--- a/csrc/mmdeploy/core/model.cpp
+++ b/csrc/mmdeploy/core/model.cpp
@@ -5,6 +5,7 @@
 #include "mmdeploy/core/logger.h"
 #include "mmdeploy/core/model_impl.h"
 #include "mmdeploy/core/utils/filesystem.h"
+#include "mmdeploy/core/utils/formatter.h"
 
 using namespace std;
 
@@ -12,7 +13,7 @@ namespace mmdeploy::framework {
 
 Model::Model(const std::string& model_path) {
   if (auto r = Model::Init(model_path); !r) {
-    MMDEPLOY_ERROR("load model failed. Its file path is '{}'", model_path);
+    MMDEPLOY_ERROR("Failed to load model \"{}\"", model_path);
     r.error().throw_exception();
   }
 }
@@ -22,50 +23,38 @@ Model::Model(const void* buffer, size_t size) { Init(buffer, size).value(); }
 Result<void> Model::Init(const std::string& model_path) {
   model_path_ = model_path;
   if (!fs::exists(model_path)) {
-    MMDEPLOY_ERROR("'{}' doesn't exist", model_path);
+    MMDEPLOY_ERROR("File not found: \"{}\"", model_path);
     return Status(eFileNotExist);
   }
 
-  auto registry = ModelRegistry::Get();
-  auto entries = registry.ListEntries();
-
-  for (auto& entry : entries) {
-    auto impl = entry.creator();
-    if (!impl->Init(model_path)) {
-      continue;
+  for (const auto& creator : gRegistry<ModelImpl>().Creators()) {
+    if (auto impl = creator->Create(); impl->Init(model_path)) {
+      OUTCOME_TRY(auto meta, impl->ReadMeta());
+      impl_ = std::move(impl);
+      meta_ = std::move(meta);
+      MMDEPLOY_INFO("[{}] Load model: \"{}\"", creator->name(), model_path);
+      return success();
     }
-    OUTCOME_TRY(auto meta, impl->ReadMeta());
-
-    MMDEPLOY_INFO("{} successfully load model {}", entry.name, model_path);
-    impl_ = std::move(impl);
-    meta_ = std::move(meta);
-    return success();
   }
-
-  MMDEPLOY_ERROR("no ModelImpl can read model {}", model_path);
+  MMDEPLOY_ERROR("Failed to load model: \"{}\", implementations tried: {}", model_path,
+                 gRegistry<ModelImpl>().List());
   return Status(eNotSupported);
 }
 
 const std::string& Model::GetModelPath() const { return model_path_; }
 
 Result<void> Model::Init(const void* buffer, size_t size) {
-  auto registry = ModelRegistry::Get();
-  auto entries = registry.ListEntries();
-
-  for (auto& entry : entries) {
-    auto impl = entry.creator();
-    if (!impl->Init(buffer, size)) {
-      continue;
+  for (const auto& creator : gRegistry<ModelImpl>().Creators()) {
+    if (auto impl = creator->Create(); impl->Init(buffer, size)) {
+      OUTCOME_TRY(auto meta, impl->ReadMeta());
+      impl_ = std::move(impl);
+      meta_ = std::move(meta);
+      MMDEPLOY_INFO("[{}] Parse model", creator->name());
+      return success();
     }
-    OUTCOME_TRY(auto meta, impl->ReadMeta());
-
-    MMDEPLOY_INFO("Successfully load model {}", entry.name);
-    impl_ = std::move(impl);
-    meta_ = std::move(meta);
-    return success();
   }
-
-  MMDEPLOY_ERROR("no ModelImpl can parse buffer");
+  MMDEPLOY_ERROR("Failed to parse model buffer, implementations tried: {}",
+                 gRegistry<ModelImpl>().List());
   return Status(eNotSupported);
 }
 
@@ -75,7 +64,7 @@ Result<model_meta_info_t> Model::GetModelConfig(const std::string& name) const {
       return info;
     }
   }
-  MMDEPLOY_ERROR("cannot find model '{}' in meta file", name);
+  MMDEPLOY_ERROR("Cannot find model '{}' in meta file", name);
   return Status(eEntryNotFound);
 }
 
@@ -83,21 +72,6 @@ Result<std::string> Model::ReadFile(const std::string& file_path) noexcept {
   return impl_->ReadFile(file_path);
 }
 
-ModelRegistry& ModelRegistry::Get() {
-  static ModelRegistry inst;
-  return inst;
-}
-
-Result<void> ModelRegistry::Register(const std::string& name, Creator creator) {
-  for (auto& entry : entries_) {
-    if (entry.name == name) {
-      MMDEPLOY_ERROR("{} is already registered", name);
-      return Status(eFail);
-    }
-  }
-  MMDEPLOY_INFO("Register '{}'", name);
-  entries_.push_back({name, std::move(creator)});
-  return success();
-}
+MMDEPLOY_DEFINE_REGISTRY(ModelImpl);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/core/model.h b/csrc/mmdeploy/core/model.h
index dd2baa53ec..db9bbce1e8 100644
--- a/csrc/mmdeploy/core/model.h
+++ b/csrc/mmdeploy/core/model.h
@@ -9,8 +9,8 @@
 #include <vector>
 
 #include "mmdeploy/core/mpl/type_traits.h"
-#include "serialization.h"
-#include "types.h"
+#include "mmdeploy/core/serialization.h"
+#include "mmdeploy/core/types.h"
 
 namespace mmdeploy {
 
@@ -37,31 +37,21 @@ class ModelImpl;
 
 /**
  * @class Model
- * @brief Read sdk model from file.
- * @note there might be more than one models in an sdk model file. For example,
- * in case of faster-rcnn model, it splits into two models, one is rpn and the
- * other is cnn for roi classification.
+ * @brief Load SDK model from file or buffer.
  */
 class MMDEPLOY_API Model {
  public:
   Model() = default;
 
-  /**
-   * @brief construct `Model` with an sdk model's path
-   * @param model_path file path of an sdk model. It can be a file or a
-   * directory. Refer to `Load`
-   * @note An exception might be threw. `Try...catch...` is strongly recommended
-   * when this constructor is used
-   */
   explicit Model(const std::string& model_path);
 
-  Model(const void* buffer, size_t size);
+  explicit Model(const void* buffer, size_t size);
 
   ~Model() = default;
 
   /**
-   * @brief Load an sdk model.
-   * @param model_path file path of an sdk model. It can be a file or a
+   * @brief Load SDK model.
+   * @param model_path file path of the model. It can be a file or a
    * directory.
    * @return status with an error code.
    */
@@ -70,24 +60,22 @@ class MMDEPLOY_API Model {
   Result<void> Init(const void* buffer, size_t size);
 
   /**
-   * @brief Return a specified model's meta info
-   * @param name the name of a model in sdk model file
+   * @brief Return the model's meta info
+   * @param name the name of a model in the SDK model file
    * @return
    */
   Result<model_meta_info_t> GetModelConfig(const std::string& name) const;
 
   /**
-   * @brief Read specified file from an sdk model
-   * @param file_path path relative to the root directory of an sdk model.
-   * @return the content of specified file if success, which can be accessed by
-   * `Result<T>.value()`. Otherwise, error code is returned that can be obtained
-   * by `Result<T>.error()`
+   * @brief Read file from the SDK model
+   * @param file_path path relative to the root directory of the model.
+   * @return the content of file on success
    */
   Result<std::string> ReadFile(const std::string& file_path) noexcept;
 
   /**
-   * @brief get meta information of an sdk model
-   * @return sdk model's meta information
+   * @brief get meta information of the model
+   * @return SDK model's meta information
    */
   const deploy_meta_info_t& meta() const { return meta_; }
 
@@ -109,55 +97,6 @@ class MMDEPLOY_API Model {
   deploy_meta_info_t meta_;
 };
 
-/**
- * @class ModelRegistry
- * @brief SDK model implementor's factory. The following code shows how to
- * register a new implementor to the factory.
- * @example
- * class ANewModelImpl : public ModelImpl {
- * };
- * class ANewModelImplRegister {
- *  public:
- *   ANewModelImplRegister() {
- *     ModelRegistry::Get().Register("ANewModelImpl",
- *     []()->unique_ptr<ModelImpl>{return make_unique<ANewModelImpl>();});
- *   }
- * };
- * ANewModelImplRegister a_new_model_impl_register;
- */
-class MMDEPLOY_API ModelRegistry {
- public:
-  using Creator = std::function<std::unique_ptr<ModelImpl>()>;
-  struct Entry {
-    std::string name;
-    Creator creator;
-  };
-
-  /**
-   * @brief Return global instance of `ModelRegistry`
-   */
-  static ModelRegistry& Get();
-
-  /**
-   * @brief Register an sdk model format denoted by an specified `ModelImpl`
-   * @param name sdk model implementor's name
-   * @param creator method to create an sdk model implementor
-   * @return Status of registering result
-   */
-  Result<void> Register(const std::string& name, Creator creator);
-
-  /**
-   * @brief Return the registered sdk model implementors
-   */
-  const std::vector<Entry>& ListEntries() const { return entries_; }
-
- private:
-  ModelRegistry() = default;
-
- private:
-  std::vector<Entry> entries_;
-};
-
 }  // namespace framework
 
 MMDEPLOY_REGISTER_TYPE_ID(framework::Model, 5);
diff --git a/csrc/mmdeploy/core/model_impl.h b/csrc/mmdeploy/core/model_impl.h
index 4a7f52f0bd..74b3b67dd4 100644
--- a/csrc/mmdeploy/core/model_impl.h
+++ b/csrc/mmdeploy/core/model_impl.h
@@ -3,54 +3,44 @@
 #ifndef MMDEPLOY_MODEL_IMPL_H
 #define MMDEPLOY_MODEL_IMPL_H
 
-#include "model.h"
+#include "mmdeploy/core/model.h"
+#include "mmdeploy/core/registry.h"
 
 namespace mmdeploy::framework {
 
 /**
  * @class ModelImpl
- * @brief sdk model's implementation interface
+ * @brief SDK model's implementation interface
  */
 class ModelImpl {
  public:
   virtual ~ModelImpl() = default;
 
   /**
-   * @brief Check the sdk model file's format, to find whether this `ModelImpl`
-   * can read it.
-   * @param sdk_model_path file path of sdk model. It can be a directory, or a
-   * file.
+   * @brief Load an SDK model.
+   * @param model_path path of the model. It can be a file or a directory.
    * @return status with an error code.
    */
-  //  virtual bool Accept(const std::string& sdk_model_path) = 0;
-
-  /**
-   * @brief Load an sdk model.
-   * @param sdk_model_path file path of an sdk model. It can be a file or a
-   * directory.
-   * @note MAKE SURE `Accept` is called before invoking `Load`
-   * @return status with an error code.
-   */
-  virtual Result<void> Init(const std::string& sdk_model_path) { return Status(eNotSupported); }
+  virtual Result<void> Init(const std::string& model_path) { return Status(eNotSupported); }
 
   virtual Result<void> Init(const void* buffer, size_t size) { return Status(eNotSupported); }
 
   /**
-   * @brief Read specified file from an sdk model
-   * @param file_path path relative to the root directory of an sdk model.
-   * @return the content of specified file if success, which can be accessed by
-   * `Result<T>.value()`. Otherwise, error code is returned that can be obtained
-   * by `Result<T>.error()`
+   * @brief Read specified file from a SDK model
+   * @param file_path path relative to the root directory of the model.
+   * @return the content of the file on success
    */
   virtual Result<std::string> ReadFile(const std::string& file_path) const = 0;
 
   /**
    * @brief get meta information of an sdk model
-   * @return sdk model's meta information
+   * @return SDK model's meta information
    */
   virtual Result<deploy_meta_info_t> ReadMeta() const = 0;
 };
 
+MMDEPLOY_DECLARE_REGISTRY(ModelImpl, std::unique_ptr<ModelImpl>());
+
 }  // namespace mmdeploy::framework
 
 #endif  // MMDEPLOY_MODEL_IMPL_H
diff --git a/csrc/mmdeploy/core/module.h b/csrc/mmdeploy/core/module.h
index 5273b3f16d..c158887c45 100644
--- a/csrc/mmdeploy/core/module.h
+++ b/csrc/mmdeploy/core/module.h
@@ -16,7 +16,7 @@ class MMDEPLOY_API Module {
   virtual Result<Value> Process(const Value& args) = 0;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(Module);
+MMDEPLOY_DECLARE_REGISTRY(Module, std::unique_ptr<Module>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/core/mpl/span.h b/csrc/mmdeploy/core/mpl/span.h
index 29d49f6a78..9b081bb4d8 100644
--- a/csrc/mmdeploy/core/mpl/span.h
+++ b/csrc/mmdeploy/core/mpl/span.h
@@ -68,7 +68,6 @@ class Span {
   template <std::size_t N>
   constexpr Span(element_type (&arr)[N]) noexcept : data_(std::data(arr)), size_(N) {}
 
-  template <std::size_t N>
   constexpr Span(const Span& other) noexcept : data_(std::data(other)), size_(std::size(other)) {}
 
   constexpr iterator begin() const noexcept { return data_; }
diff --git a/csrc/mmdeploy/core/net.cpp b/csrc/mmdeploy/core/net.cpp
index 73b8270f7c..0864bcf1c5 100644
--- a/csrc/mmdeploy/core/net.cpp
+++ b/csrc/mmdeploy/core/net.cpp
@@ -4,8 +4,8 @@
 
 #include "registry.h"
 
-namespace mmdeploy {
+namespace mmdeploy::framework {
 
-MMDEPLOY_DEFINE_REGISTRY(framework::Net);
+MMDEPLOY_DEFINE_REGISTRY(Net);
 
-}  // namespace mmdeploy
+}  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/core/net.h b/csrc/mmdeploy/core/net.h
index c601f685c3..bfc7e6d416 100644
--- a/csrc/mmdeploy/core/net.h
+++ b/csrc/mmdeploy/core/net.h
@@ -8,9 +8,7 @@
 #include "mmdeploy/core/tensor.h"
 #include "mmdeploy/core/value.h"
 
-namespace mmdeploy {
-
-namespace framework {
+namespace mmdeploy::framework {
 
 class Net {
  public:
@@ -24,10 +22,8 @@ class Net {
   virtual Result<void> ForwardAsync(Event* event) = 0;
 };
 
-}  // namespace framework
-
-MMDEPLOY_DECLARE_REGISTRY(framework::Net);
+MMDEPLOY_DECLARE_REGISTRY(Net, std::unique_ptr<Net>(const Value& config));
 
-}  // namespace mmdeploy
+}  // namespace mmdeploy::framework
 
 #endif  // MMDEPLOY_SRC_CORE_NET_H_
diff --git a/csrc/mmdeploy/core/registry.cpp b/csrc/mmdeploy/core/registry.cpp
index 78a341f6ee..dab2c92416 100644
--- a/csrc/mmdeploy/core/registry.cpp
+++ b/csrc/mmdeploy/core/registry.cpp
@@ -2,53 +2,80 @@
 
 #include "mmdeploy/core/registry.h"
 
-namespace mmdeploy {
+#include <algorithm>
+#include <cassert>
 
-Registry<void>::Registry() = default;
+#include "mmdeploy/core/logger.h"
 
-Registry<void>::~Registry() = default;
+namespace mmdeploy {
 
-bool Registry<void>::AddCreator(Creator<void>& creator) {
-  MMDEPLOY_DEBUG("Adding creator: {}", creator.GetName());
-  auto key = creator.GetName();
-  if (entries_.find(key) == entries_.end()) {
-    entries_.insert(std::make_pair(key, &creator));
-    return true;
-  }
+namespace _registry {
 
-  for (auto iter = entries_.lower_bound(key); iter != entries_.upper_bound(key); ++iter) {
-    if (iter->second->GetVersion() == creator.GetVersion()) {
-      return false;
-    }
+struct Registry<void>::Impl {
+  template <typename It>
+  auto convert(It u, It v) {
+    return std::pair{creators_.begin() + (u - names_.begin()),
+                     creators_.begin() + (v - names_.begin())};
   }
 
-  entries_.insert(std::make_pair(key, &creator));
-  return true;
-}
-
-Creator<void>* Registry<void>::GetCreator(const std::string& type, int version) {
-  auto iter = entries_.find(type);
-  if (iter == entries_.end()) {
+  Creator<void>* Get(const string_view& name, int version) {
+    const auto& [u, v] = std::equal_range(names_.begin(), names_.end(), name);
+    const auto& [i, j] = convert(u, v);
+    if (version == -1) {
+      if (auto n = j - i; n == 1) {
+        return *i;
+      }
+      return nullptr;
+    }
+    for (const auto& creator : iterator_range(i, j)) {
+      if (creator->version() == version) {
+        return creator;
+      }
+    }
     return nullptr;
   }
-  if (0 == version) {
-    return iter->second;
-  }
 
-  for (auto iter = entries_.lower_bound(type); iter != entries_.upper_bound(type); ++iter) {
-    if (iter->second->GetVersion() == version) {
-      return iter->second;
+  bool Add(Creator<void>& creator) {
+    const auto& [u, v] = std::equal_range(names_.begin(), names_.end(), creator.name());
+    const auto& [i, j] = convert(u, v);
+    if (i != j) {
+      for (const auto& other : iterator_range(i, j)) {
+        if (creator.version() == other->version()) {
+          MMDEPLOY_WARN("Adding duplicated creator ({}, {}).", creator.name(), creator.version());
+          return false;
+        }
+      }
     }
+    names_.insert(v, creator.name());
+    creators_.insert(j, &creator);
+    return true;
   }
-  return nullptr;
+
+  Span<Creator<void>*> Creators() { return creators_; }
+
+  std::vector<Creator<void>*> creators_;
+  std::vector<string_view> names_;
+};
+
+Registry<void>::Registry() : impl_(std::make_unique<Impl>()) {}
+
+Registry<void>::~Registry() = default;
+
+bool Registry<void>::AddCreator(Creator<void>& creator) {
+  assert(impl_);
+  return impl_->Add(creator);
 }
 
-std::vector<std::string> Registry<void>::List() {
-  std::vector<std::string> list;
-  for (const auto& [name, _] : entries_) {
-    list.push_back(name);
-  }
-  return list;
+Creator<void>* Registry<void>::GetCreator(const std::string_view& name, int version) {
+  assert(impl_);
+  return impl_->Get(name, version);
 }
 
+Span<Creator<void>*> Registry<void>::Creators() {
+  assert(impl_);
+  return impl_->Creators();
+}
+
+}  // namespace _registry
+
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/core/registry.h b/csrc/mmdeploy/core/registry.h
index a6bcc1cf66..cdb5973e37 100644
--- a/csrc/mmdeploy/core/registry.h
+++ b/csrc/mmdeploy/core/registry.h
@@ -3,55 +3,98 @@
 #ifndef MMDEPLOY_REGISTRY_H
 #define MMDEPLOY_REGISTRY_H
 
-#include <iostream>
-#include <map>
+#include <functional>
 #include <memory>
+#include <optional>
 #include <string>
+#include <string_view>
 #include <vector>
 
-#include "macro.h"
-#include "value.h"
+#include "mmdeploy/core/macro.h"
+#include "mmdeploy/core/mpl/span.h"
 
 namespace mmdeploy {
 
-namespace detail {
+template <typename T>
+struct basic_type {
+  using type = T;
+};
+
+template <typename Iterator>
+class iterator_range {
+ public:
+  explicit iterator_range(Iterator first, Iterator last) : first_(first), last_(last) {}
+  explicit iterator_range(std::pair<Iterator, Iterator> range)
+      : iterator_range(range.first, range.second) {}
 
-template <typename EntryType, typename = void>
-struct get_return_type {
-  using type = std::unique_ptr<EntryType>;
+  auto begin() noexcept { return first_; }
+  auto end() noexcept { return last_; }
+
+ private:
+  Iterator first_;
+  Iterator last_;
 };
 
-template <typename EntryType>
-struct get_return_type<EntryType, std::void_t<typename EntryType::type>> {
-  using type = typename EntryType::type;
+namespace _registry {
+
+using std::optional;
+using std::string_view;
+
+template <typename T, typename = void>
+struct _get_signature {
+  static_assert(!std::is_same_v<T, T>, "tag T is not associated with a signature");
 };
 
-template <typename EntryType>
-using get_return_type_t = typename get_return_type<EntryType>::type;
+template <typename T>
+using get_signature_t = decltype(get_signature(basic_type<T>{}));
+
+template <typename T>
+struct _get_signature<T, std::void_t<get_signature_t<T>>> {
+  using type = typename get_signature_t<T>::type;
+};
 
-}  // namespace detail
+template <typename T>
+using GetSignature = typename _get_signature<T>::type;
 
-template <class EntryType>
+template <typename Tag>
 class Creator;
 
 template <>
-class Creator<void> {
+class MMDEPLOY_API Creator<void> {
  public:
   virtual ~Creator() = default;
-  virtual const char* GetName() const = 0;
-  virtual int GetVersion() const { return 0; }
+  virtual string_view name() const noexcept = 0;
+  virtual int version() const noexcept { return 0; }
 };
 
-template <typename EntryType>
-class Creator : public Creator<void> {
+template <typename Ret, typename... Args>
+class MMDEPLOY_API Creator<Ret(Args...)> : public Creator<void> {
  public:
-  using ReturnType = detail::get_return_type_t<EntryType>;
+  virtual Ret Create(Args... args) = 0;
+};
+
+template <typename Tag>
+class SimpleCreator;
 
+template <typename Ret, typename... Args>
+class SimpleCreator<Ret(Args...)> : public Creator<Ret(Args...)> {
  public:
-  virtual ReturnType Create(const Value& args) = 0;
+  using FunctionType = std::function<Ret(Args...)>;
+
+  SimpleCreator(const string_view& name, int version, FunctionType func)
+      : name_(name), version_(version), func_(std::move(func)) {}
+
+  string_view name() const noexcept override { return name_; }
+  int version() const noexcept override { return version_; }
+  Ret Create(Args... args) override { return func_(args...); }
+
+ private:
+  std::string name_;
+  int version_;
+  FunctionType func_;
 };
 
-template <class EntryType>
+template <typename Tag>
 class Registry;
 
 template <>
@@ -63,67 +106,123 @@ class MMDEPLOY_API Registry<void> {
 
   bool AddCreator(Creator<void>& creator);
 
-  Creator<void>* GetCreator(const std::string& type, int version = 0);
+  Creator<void>* GetCreator(const string_view& name, int version);
 
-  std::vector<std::string> List();
+  Span<Creator<void>*> Creators();
 
  private:
-  std::multimap<std::string, Creator<void>*> entries_;
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
+template <typename Signature>
+struct _result_of;
+
+template <typename R, typename... As>
+struct _result_of<R(As...)> {
+  using type = R;
 };
 
-template <class EntryType>
+template <typename Tag>
 class Registry : public Registry<void> {
  public:
-  bool AddCreator(Creator<EntryType>& creator) { return Registry<void>::AddCreator(creator); }
+  using Signature = GetSignature<Tag>;
+  using CreatorType = Creator<Signature>;
 
-  Creator<EntryType>* GetCreator(const std::string& type, int version = 0) {
-    auto creator = Registry<void>::GetCreator(type, version);
-    return static_cast<Creator<EntryType>*>(creator);
+  bool Add(CreatorType& creator) & { return AddCreator(creator); }
+
+  CreatorType* Get(const string_view& name, int version) & {
+    return static_cast<CreatorType*>(GetCreator(name, version));
   }
 
-  static Registry& Get();
+  CreatorType* Get(const string_view& name) & { return Get(name, -1); }
 
- private:
-  Registry() = default;
+  template <typename... Args>
+  auto Create(const std::pair<string_view, int>& desc,
+              Args&&... args) & -> optional<typename _result_of<Signature>::type> {
+    if (auto creator = Get(desc.first, desc.second); creator) {
+      return creator->Create((Args &&) args...);
+    } else {
+      return std::nullopt;
+    }
+  }
+
+  template <typename... Args>
+  auto Create(const string_view& name, Args&&... args) & {
+    return Create(std::pair{name, -1}, (Args &&) args...);
+  }
+
+  Span<CreatorType*> Creators() & {
+    auto creators = Registry<void>::Creators();
+    return {reinterpret_cast<CreatorType**>(creators.data()), creators.size()};
+  }
+
+  auto List() & {
+    std::vector<std::pair<string_view, int>> list;
+    for (const auto& creator : Creators()) {
+      list.emplace_back(creator->name(), creator->version());
+    }
+    return list;
+  }
 };
 
-template <typename EntryType, typename CreatorType>
+template <typename Tag>
+auto gRegistry() -> decltype((get_registry(basic_type<Tag>{}))) {
+  return get_registry(basic_type<Tag>{});
+}
+
+template <typename F>
 class Registerer {
  public:
-  Registerer() { Registry<EntryType>::Get().AddCreator(inst_); }
+  explicit Registerer(F f) : func_(std::move(f)) { func_(); }
 
  private:
-  CreatorType inst_;
+  F func_;
 };
 
+}  // namespace _registry
+
+using _registry::gRegistry;
+using _registry::Registerer;
+using _registry::Registry;
+
+template <typename Tag>
+using Creator = _registry::Creator<_registry::GetSignature<Tag>>;
+
+template <typename Tag>
+using SimpleCreator = _registry::SimpleCreator<_registry::GetSignature<Tag>>;
+
 }  // namespace mmdeploy
 
-#define MMDEPLOY_DECLARE_REGISTRY(EntryType) \
-  template <>                                \
-  Registry<EntryType>& Registry<EntryType>::Get();
+// Specify creator signature for tag
+#define MMDEPLOY_CREATOR_SIGNATURE(tag, signature) \
+  ::mmdeploy::basic_type<signature> get_signature(::mmdeploy::basic_type<tag>);
 
-#define MMDEPLOY_DEFINE_REGISTRY(EntryType)                         \
-  template <>                                                       \
-  MMDEPLOY_EXPORT Registry<EntryType>& Registry<EntryType>::Get() { \
-    static Registry v;                                              \
-    return v;                                                       \
+#define MMDEPLOY_DECLARE_REGISTRY(tag, signature) \
+  MMDEPLOY_CREATOR_SIGNATURE(tag, signature)      \
+  MMDEPLOY_API ::mmdeploy::Registry<tag>& get_registry(::mmdeploy::basic_type<tag>);
+
+#define MMDEPLOY_DECLARE_REGISTRY_EXPAND(tag, signature)        \
+  MMDEPLOY_CREATOR_SIGNATURE(tag, MMDEPLOY_PP_EXPAND signature) \
+  MMDEPLOY_API ::mmdeploy::Registry<tag>& get_registry(::mmdeploy::basic_type<tag>);
+
+#define MMDEPLOY_DEFINE_REGISTRY(tag)                                    \
+  ::mmdeploy::Registry<tag>& get_registry(::mmdeploy::basic_type<tag>) { \
+    static ::mmdeploy::Registry<tag> instance{};                         \
+    return instance;                                                     \
   }
 
-#define REGISTER_MODULE(EntryType, CreatorType) \
-  static ::mmdeploy::Registerer<EntryType, CreatorType> g_register_##EntryType##_##CreatorType{};
-
-#define DECLARE_AND_REGISTER_MODULE(base_type, module_name, version)   \
-  class module_name##Creator : public ::mmdeploy::Creator<base_type> { \
-   public:                                                             \
-    module_name##Creator() = default;                                  \
-    ~module_name##Creator() = default;                                 \
-    const char* GetName() const override { return #module_name; }      \
-    int GetVersion() const override { return version; }                \
-                                                                       \
-    std::unique_ptr<base_type> Create(const Value& value) override {   \
-      return std::make_unique<module_name>(value);                     \
-    }                                                                  \
-  };                                                                   \
-  REGISTER_MODULE(base_type, module_name##Creator);
+#define MMDEPLOY_REGISTER_CREATOR(tag, creator_type)                    \
+  static ::mmdeploy::Registerer MMDEPLOY_ANONYMOUS_VARIABLE(register_){ \
+      [creator = creator_type{}]() mutable { ::mmdeploy::gRegistry<tag>().Add(creator); }};
+
+#define MMDEPLOY_CREATOR_DESC(name, version) #name, version
+
+#define MMDEPLOY_REGISTER_FACTORY_FUNC(tag, creator_desc, func)                                  \
+  static ::mmdeploy::Registerer MMDEPLOY_ANONYMOUS_VARIABLE(register_){                          \
+      [creator =                                                                                 \
+           ::mmdeploy::SimpleCreator<tag>(MMDEPLOY_CREATOR_DESC creator_desc, func)]() mutable { \
+        ::mmdeploy::gRegistry<tag>().Add(creator);                                               \
+      }};
 
 #endif  // MMDEPLOY_REGISTRY_H
diff --git a/csrc/mmdeploy/execution/schedulers/registry.h b/csrc/mmdeploy/execution/schedulers/registry.h
index 525eebbef3..3db4e9feee 100644
--- a/csrc/mmdeploy/execution/schedulers/registry.h
+++ b/csrc/mmdeploy/execution/schedulers/registry.h
@@ -4,22 +4,15 @@
 #define MMDEPLOY_CSRC_EXECUTION_SCHEDULERS_REGISTRY_H_
 
 #include "mmdeploy/core/registry.h"
+#include "mmdeploy/core/value.h"
 #include "mmdeploy/execution/type_erased.h"
 
 namespace mmdeploy {
 
-namespace detail {
-
-template <>
-struct get_return_type<TypeErasedScheduler<Value>> {
-  using type = TypeErasedScheduler<Value>;
-};
-
-}  // namespace detail
-
 MMDEPLOY_REGISTER_TYPE_ID(TypeErasedScheduler<Value>, 8);
 
-MMDEPLOY_DECLARE_REGISTRY(TypeErasedScheduler<Value>);
+MMDEPLOY_DECLARE_REGISTRY(TypeErasedScheduler<Value>,
+                          TypeErasedScheduler<Value>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/execution/schedulers/schedulers.cpp b/csrc/mmdeploy/execution/schedulers/schedulers.cpp
index 77cf5ad6b1..2703e136e1 100644
--- a/csrc/mmdeploy/execution/schedulers/schedulers.cpp
+++ b/csrc/mmdeploy/execution/schedulers/schedulers.cpp
@@ -11,14 +11,8 @@ namespace mmdeploy {
 
 using Scheduler = TypeErasedScheduler<Value>;
 
-class InlineSchedulerCreator : public Creator<Scheduler> {
- public:
-  const char* GetName() const override { return "Inline"; }
-  int GetVersion() const override { return 0; }
-  ReturnType Create(const Value&) override { return ReturnType{InlineScheduler{}}; }
-};
-
-REGISTER_MODULE(Scheduler, InlineSchedulerCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Scheduler, (Inline, 0),
+                               [](const Value&) { return Scheduler{InlineScheduler{}}; });
 
 namespace {
 
@@ -35,36 +29,21 @@ Scheduler CreateFromContext(std::unique_ptr<Context> context) {
 
 }  // namespace
 
-class SingleThreadSchedCreator : public Creator<Scheduler> {
- public:
-  const char* GetName() const override { return "SingleThread"; }
-  int GetVersion() const override { return 0; }
-  ReturnType Create(const Value&) override {
-    return CreateFromContext(std::make_unique<_single_thread_context::SingleThreadContext>());
-  }
-};
+MMDEPLOY_REGISTER_FACTORY_FUNC(Scheduler, (SingleThread, 0), [](const Value&) {
+  return CreateFromContext(std::make_unique<_single_thread_context::SingleThreadContext>());
+});
 
-REGISTER_MODULE(Scheduler, SingleThreadSchedCreator);
-
-class StaticThreadPoolSchedCreator : public Creator<Scheduler> {
- public:
-  const char* GetName() const override { return "ThreadPool"; }
-  int GetVersion() const override { return 0; }
-  ReturnType Create(const Value& cfg) override {
-    auto num_threads = -1;
-    if (cfg.is_object() && cfg.contains("num_threads")) {
-      num_threads = cfg["num_threads"].get<int>();
-    }
-    if (num_threads >= 1) {
-      return CreateFromContext(
-          std::make_unique<__static_thread_pool::StaticThreadPool>(num_threads));
-    } else {
-      return CreateFromContext(std::make_unique<__static_thread_pool::StaticThreadPool>());
-    }
+MMDEPLOY_REGISTER_FACTORY_FUNC(Scheduler, (ThreadPool, 0), [](const Value& cfg) {
+  auto num_threads = -1;
+  if (cfg.is_object() && cfg.contains("num_threads")) {
+    num_threads = cfg["num_threads"].get<int>();
   }
-};
-
-REGISTER_MODULE(Scheduler, StaticThreadPoolSchedCreator);
+  if (num_threads >= 1) {
+    return CreateFromContext(std::make_unique<__static_thread_pool::StaticThreadPool>(num_threads));
+  } else {
+    return CreateFromContext(std::make_unique<__static_thread_pool::StaticThreadPool>());
+  }
+});
 
 struct ValueAssembler {
   using range_t = std::pair<size_t, size_t>;
@@ -117,27 +96,22 @@ TimedSingleThreadContext& gTimedSingleThreadContext() {
   return context;
 }
 
-class DynamicBatchSchedCreator : public Creator<Scheduler> {
- public:
-  const char* GetName() const override { return "DynamicBatch"; }
-  int GetVersion() const override { return 0; }
-  ReturnType Create(const Value& cfg) override {
-    using SchedulerType =
-        DynamicBatchScheduler<InlineScheduler, TypeErasedScheduler<Value>, ValueAssembler>;
-    auto scheduler = cfg["scheduler"].get<TypeErasedScheduler<Value>>();
-    auto max_batch_size = cfg["max_batch_size"].get<int>();
-
-    TimedSingleThreadContext* timer{};
-    auto timeout = cfg["timeout"].get<int>();
-    if (timeout >= 0) {
-      timer = &gTimedSingleThreadContext();
-    }
-    return ReturnType{SchedulerType{inline_scheduler, std::move(scheduler), timer,
-                                    (size_t)max_batch_size, std::chrono::microseconds(timeout)}};
+static Scheduler CreateDynamicBatchScheduler(const Value& cfg) {
+  using SchedulerType =
+      DynamicBatchScheduler<InlineScheduler, TypeErasedScheduler<Value>, ValueAssembler>;
+  auto scheduler = cfg["scheduler"].get<TypeErasedScheduler<Value>>();
+  auto max_batch_size = cfg["max_batch_size"].get<int>();
+
+  TimedSingleThreadContext* timer{};
+  auto timeout = cfg["timeout"].get<int>();
+  if (timeout >= 0) {
+    timer = &gTimedSingleThreadContext();
   }
-};
+  return Scheduler{SchedulerType{inline_scheduler, std::move(scheduler), timer,
+                                 (size_t)max_batch_size, std::chrono::microseconds(timeout)}};
+}
 
-REGISTER_MODULE(Scheduler, DynamicBatchSchedCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Scheduler, (DynamicBatch, 0), CreateDynamicBatchScheduler);
 
 MMDEPLOY_DEFINE_REGISTRY(TypeErasedScheduler<Value>);
 
diff --git a/csrc/mmdeploy/graph/cond.cpp b/csrc/mmdeploy/graph/cond.cpp
index 3ef5748889..2e632277af 100644
--- a/csrc/mmdeploy/graph/cond.cpp
+++ b/csrc/mmdeploy/graph/cond.cpp
@@ -111,14 +111,8 @@ Result<unique_ptr<Node>> CondBuilder::BuildImpl() {
   return Status(eFail);
 }
 
-class CondCreator : public Creator<Builder> {
- public:
-  const char* GetName() const override { return "Cond"; }
-  unique_ptr<Builder> Create(const Value& config) override {
-    return std::make_unique<CondBuilder>(config);
-  }
-};
-
-REGISTER_MODULE(Builder, CondCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Builder, (Cond, 0), [](const Value& config) {
+  return std::make_unique<CondBuilder>(config);
+})
 
 }  // namespace mmdeploy::graph
diff --git a/csrc/mmdeploy/graph/inference.cpp b/csrc/mmdeploy/graph/inference.cpp
index dc002091c4..8933ab8c91 100644
--- a/csrc/mmdeploy/graph/inference.cpp
+++ b/csrc/mmdeploy/graph/inference.cpp
@@ -67,14 +67,8 @@ Result<void> InferenceBuilder::CheckOutputs(Builder& builder) {
   return success();
 }
 
-class InferenceCreator : public Creator<Builder> {
- public:
-  const char* GetName() const override { return "Inference"; }
-  unique_ptr<Builder> Create(const Value& config) override {
-    return std::make_unique<InferenceBuilder>(config);
-  }
-};
-
-REGISTER_MODULE(Builder, InferenceCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Builder, (Inference, 0), [](const Value& config) {
+  return std::make_unique<InferenceBuilder>(config);
+});
 
 }  // namespace mmdeploy::graph
diff --git a/csrc/mmdeploy/graph/pipeline.cpp b/csrc/mmdeploy/graph/pipeline.cpp
index a715d7056c..6b328f3008 100644
--- a/csrc/mmdeploy/graph/pipeline.cpp
+++ b/csrc/mmdeploy/graph/pipeline.cpp
@@ -14,13 +14,8 @@ Result<unique_ptr<Node>> PipelineBuilder::BuildImpl() {
   return StaticRouterBuilder{}.Build(config_).value();
 }
 
-class PipelineCreator : public Creator<Builder> {
- public:
-  const char* GetName() const override { return "Pipeline"; }
-  unique_ptr<Builder> Create(const Value& config) override {
-    return std::make_unique<PipelineBuilder>(config);
-  }
-};
-REGISTER_MODULE(Builder, PipelineCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Builder, (Pipeline, 0), [](const Value& config) {
+  return std::make_unique<PipelineBuilder>(config);
+});
 
 }  // namespace mmdeploy::graph
diff --git a/csrc/mmdeploy/graph/task.cpp b/csrc/mmdeploy/graph/task.cpp
index 2f525558e0..69b2675a02 100644
--- a/csrc/mmdeploy/graph/task.cpp
+++ b/csrc/mmdeploy/graph/task.cpp
@@ -45,7 +45,7 @@ namespace {
 
 inline Result<unique_ptr<Module>> CreateModule(const Value& config) {
   auto type = config["module"].get<std::string>();
-  auto creator = Registry<Module>::Get().GetCreator(type);
+  auto creator = gRegistry<Module>().Get(type);
   if (!creator) {
     MMDEPLOY_ERROR("failed to find module creator: {}", type);
     return Status(eEntryNotFound);
@@ -86,13 +86,8 @@ Result<unique_ptr<Node>> TaskBuilder::BuildImpl() {
   }
 }
 
-class TaskCreator : public Creator<Builder> {
- public:
-  const char* GetName() const override { return "Task"; }
-  unique_ptr<Builder> Create(const Value& config) override {
-    return std::make_unique<TaskBuilder>(config);
-  }
-};
-REGISTER_MODULE(Builder, TaskCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Builder, (Task, 0), [](const Value& config) {
+  return std::make_unique<TaskBuilder>(config);
+});
 
 }  // namespace mmdeploy::graph
diff --git a/csrc/mmdeploy/model/directory_model_impl.cpp b/csrc/mmdeploy/model/directory_model_impl.cpp
index bca03133aa..cf698fe17b 100644
--- a/csrc/mmdeploy/model/directory_model_impl.cpp
+++ b/csrc/mmdeploy/model/directory_model_impl.cpp
@@ -55,15 +55,7 @@ class DirectoryModelImpl : public ModelImpl {
   fs::path root_;
 };
 
-class DirectoryModelRegister {
- public:
-  DirectoryModelRegister() {
-    (void)ModelRegistry::Get().Register("DirectoryModel", []() -> std::unique_ptr<ModelImpl> {
-      return std::make_unique<DirectoryModelImpl>();
-    });
-  }
-};
-
-static DirectoryModelRegister directory_model_register;
+MMDEPLOY_REGISTER_FACTORY_FUNC(ModelImpl, (DirectoryModel, 0),
+                               [] { return std::make_unique<DirectoryModelImpl>(); });
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/model/zip_model_impl.cpp b/csrc/mmdeploy/model/zip_model_impl.cpp
index 5dc0e82094..9279b18f9a 100644
--- a/csrc/mmdeploy/model/zip_model_impl.cpp
+++ b/csrc/mmdeploy/model/zip_model_impl.cpp
@@ -132,15 +132,7 @@ class ZipModelImpl : public ModelImpl {
   std::map<std::string, int> file_index_;
 };
 
-class ZipModelImplRegister {
- public:
-  ZipModelImplRegister() {
-    (void)ModelRegistry::Get().Register("ZipModel", []() -> std::unique_ptr<ModelImpl> {
-      return std::make_unique<ZipModelImpl>();
-    });
-  }
-};
-
-static ZipModelImplRegister folder_model_register;
+MMDEPLOY_REGISTER_FACTORY_FUNC(ModelImpl, (ZipModel, 0),
+                               [] { return std::make_unique<ZipModelImpl>(); });
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/acl/acl_net.cpp b/csrc/mmdeploy/net/acl/acl_net.cpp
index 334469970f..c8e83bb229 100644
--- a/csrc/mmdeploy/net/acl/acl_net.cpp
+++ b/csrc/mmdeploy/net/acl/acl_net.cpp
@@ -634,26 +634,21 @@ Result<void> AclNet::Forward() {
 
 Result<void> AclNet::ForwardAsync(Event* event) { return Status(eNotSupported); }
 
-class AclNetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "ascend"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value& args) override {
-    try {
-      auto p = std::make_unique<AclNet>();
-      if (auto r = p->Init(args)) {
-        return p;
-      } else {
-        MMDEPLOY_ERROR("error creating AclNet: {}", r.error().message().c_str());
-        return nullptr;
-      }
-    } catch (const std::exception& e) {
-      MMDEPLOY_ERROR("unhandled exception when creating AclNet: {}", e.what());
+static std::unique_ptr<Net> Create(const Value& args) {
+  try {
+    auto p = std::make_unique<AclNet>();
+    if (auto r = p->Init(args)) {
+      return p;
+    } else {
+      MMDEPLOY_ERROR("error creating AclNet: {}", r.error().message().c_str());
       return nullptr;
     }
+  } catch (const std::exception& e) {
+    MMDEPLOY_ERROR("unhandled exception when creating AclNet: {}", e.what());
+    return nullptr;
   }
-};
+}
 
-REGISTER_MODULE(Net, AclNetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (ascend, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/coreml/coreml_net.mm b/csrc/mmdeploy/net/coreml/coreml_net.mm
index 69750b6168..c95f3723ae 100644
--- a/csrc/mmdeploy/net/coreml/coreml_net.mm
+++ b/csrc/mmdeploy/net/coreml/coreml_net.mm
@@ -305,22 +305,16 @@ void RemoveModel() {
   return Status(eNotSupported);
 }
 
-class CoreMLNetCreator : public Creator<Net> {
-public:
-  const char *GetName() const override { return "coreml"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value &args) override {
-    auto p = std::make_unique<CoreMLNet>();
-    if (auto r = p->Init(args)) {
-      return p;
-    } else {
-      MMDEPLOY_ERROR("error creating CoreMLNet: {}",
-                     r.error().message().c_str());
-      return nullptr;
-    }
+static std::unique_ptr<Net> Create(const Value &args) {
+  auto p = std::make_unique<CoreMLNet>();
+  if (auto r = p->Init(args)) {
+    return p;
+  } else {
+    MMDEPLOY_ERROR("error creating CoreMLNet: {}", r.error().message().c_str());
+    return nullptr;
   }
-};
+}
 
-REGISTER_MODULE(Net, CoreMLNetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (coreml, 0), Create);
 
 } // namespace mmdeploy
diff --git a/csrc/mmdeploy/net/ncnn/ncnn_net.cpp b/csrc/mmdeploy/net/ncnn/ncnn_net.cpp
index ba04569a72..6dcd5d5822 100644
--- a/csrc/mmdeploy/net/ncnn/ncnn_net.cpp
+++ b/csrc/mmdeploy/net/ncnn/ncnn_net.cpp
@@ -133,21 +133,16 @@ Result<void> NCNNNet::Forward() {
   return success();
 }
 
-class NCNNNetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "ncnn"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value& args) override {
-    auto p = std::make_unique<NCNNNet>();
-    if (auto r = p->Init(args)) {
-      return p;
-    } else {
-      MMDEPLOY_ERROR("error creating NCNNNet: {}", r.error().message().c_str());
-      return nullptr;
-    }
+static std::unique_ptr<Net> Create(const Value& args) {
+  auto p = std::make_unique<NCNNNet>();
+  if (auto r = p->Init(args)) {
+    return p;
+  } else {
+    MMDEPLOY_ERROR("error creating NCNNNet: {}", r.error().message().c_str());
+    return nullptr;
   }
-};
+}
 
-REGISTER_MODULE(Net, NCNNNetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (ncnn, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/net_module.cpp b/csrc/mmdeploy/net/net_module.cpp
index 4d0d700fef..510329e176 100644
--- a/csrc/mmdeploy/net/net_module.cpp
+++ b/csrc/mmdeploy/net/net_module.cpp
@@ -32,10 +32,10 @@ struct NetModule::Impl {
       OUTCOME_TRY(auto config, model.GetModelConfig(name));
       device_ = context.value("device", Device{"cpu"});
       stream_ = context.value("stream", Stream::GetDefault(device_));
-      auto creator = Registry<Net>::Get().GetCreator(config.backend);
+      auto creator = gRegistry<Net>().Get(config.backend);
       if (!creator) {
         MMDEPLOY_ERROR("Net backend not found: {}, available backends: {}", config.backend,
-                       Registry<Net>::Get().List());
+                       gRegistry<Net>().List());
         return Status(eEntryNotFound);
       }
       auto net_cfg = args;
@@ -227,15 +227,7 @@ Result<Value> NetModule::operator()(const Value& input) {
   }
 }
 
-class NetModuleCreator : public Creator<Module> {
- public:
-  const char* GetName() const override { return "Net"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Module> Create(const Value& value) override {
-    return CreateTask(NetModule{value});
-  }
-};
-
-REGISTER_MODULE(Module, NetModuleCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Module, (Net, 0),
+                               [](const Value& config) { return CreateTask(NetModule{config}); });
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/openvino/openvino_net.cpp b/csrc/mmdeploy/net/openvino/openvino_net.cpp
index cdc010ded2..a294a65c5c 100644
--- a/csrc/mmdeploy/net/openvino/openvino_net.cpp
+++ b/csrc/mmdeploy/net/openvino/openvino_net.cpp
@@ -252,26 +252,21 @@ Result<void> OpenVINONet::Forward() {
   return success();
 }
 
-class OpenVINONetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "openvino"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value& args) override {
-    try {
-      auto p = std::make_unique<OpenVINONet>();
-      if (auto r = p->Init(args)) {
-        return p;
-      } else {
-        MMDEPLOY_ERROR("error creating OpenVINONet: {}", r.error().message().c_str());
-        return nullptr;
-      }
-    } catch (const std::exception& e) {
-      MMDEPLOY_ERROR("unhandled exception when creating OpenVINONet: {}", e.what());
+static std::unique_ptr<Net> Create(const Value& args) {
+  try {
+    auto p = std::make_unique<OpenVINONet>();
+    if (auto r = p->Init(args)) {
+      return p;
+    } else {
+      MMDEPLOY_ERROR("error creating OpenVINONet: {}", r.error().message().c_str());
       return nullptr;
     }
+  } catch (const std::exception& e) {
+    MMDEPLOY_ERROR("unhandled exception when creating OpenVINONet: {}", e.what());
+    return nullptr;
   }
-};
+}
 
-REGISTER_MODULE(Net, OpenVINONetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (openvino, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/ort/ort_net.cpp b/csrc/mmdeploy/net/ort/ort_net.cpp
index 44fa6b98d6..f26abb7a0d 100644
--- a/csrc/mmdeploy/net/ort/ort_net.cpp
+++ b/csrc/mmdeploy/net/ort/ort_net.cpp
@@ -74,7 +74,11 @@ Result<void> OrtNet::Init(const Value& args) {
   };
 
   for (int i = 0; i < n_inputs; ++i) {
+#if ORT_API_VERSION >= 13
+    auto input_name = session_.GetInputNameAllocated(i, allocator).release();
+#else
     auto input_name = session_.GetInputName(i, allocator);
+#endif
     auto type_info = session_.GetInputTypeInfo(i);
     auto shape = to_shape(type_info);
     MMDEPLOY_DEBUG("input {}, shape = {}", i, shape);
@@ -88,7 +92,11 @@ Result<void> OrtNet::Init(const Value& args) {
   auto n_outputs = session_.GetOutputCount();
 
   for (int i = 0; i < n_outputs; ++i) {
+#if ORT_API_VERSION >= 13
+    auto output_name = session_.GetOutputNameAllocated(i, allocator).release();
+#else
     auto output_name = session_.GetOutputName(i, allocator);
+#endif
     auto type_info = session_.GetOutputTypeInfo(i);
     auto shape = to_shape(type_info);
     MMDEPLOY_DEBUG("output {}, shape = {}", i, shape);
@@ -178,26 +186,21 @@ Result<void> OrtNet::Forward() {
   return success();
 }
 
-class OrtNetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "onnxruntime"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value& args) override {
-    try {
-      auto p = std::make_unique<OrtNet>();
-      if (auto r = p->Init(args)) {
-        return p;
-      } else {
-        MMDEPLOY_ERROR("error creating OrtNet: {}", r.error().message().c_str());
-        return nullptr;
-      }
-    } catch (const std::exception& e) {
-      MMDEPLOY_ERROR("unhandled exception when creating ORTNet: {}", e.what());
+static std::unique_ptr<Net> Create(const Value& args) {
+  try {
+    auto p = std::make_unique<OrtNet>();
+    if (auto r = p->Init(args)) {
+      return p;
+    } else {
+      MMDEPLOY_ERROR("error creating OrtNet: {}", r.error().message().c_str());
       return nullptr;
     }
+  } catch (const std::exception& e) {
+    MMDEPLOY_ERROR("unhandled exception when creating ORTNet: {}", e.what());
+    return nullptr;
   }
-};
+}
 
-REGISTER_MODULE(Net, OrtNetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (onnxruntime, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/ppl/ppl_net.cpp b/csrc/mmdeploy/net/ppl/ppl_net.cpp
index 555608737f..06f21bf579 100644
--- a/csrc/mmdeploy/net/ppl/ppl_net.cpp
+++ b/csrc/mmdeploy/net/ppl/ppl_net.cpp
@@ -343,21 +343,16 @@ Result<std::vector<TensorShape>> PPLNet::InferOutputShapes(Span<TensorShape> inp
 
 PPLNet::~PPLNet() = default;
 
-class PPLNetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "pplnn"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value& args) override {
-    auto p = std::make_unique<PPLNet>();
-    if (auto r = p->Init(args)) {
-      return p;
-    } else {
-      MMDEPLOY_ERROR("error creating PPLNet: {}", r.error().message().c_str());
-      return nullptr;
-    }
+static std::unique_ptr<Net> Create(const Value& args) {
+  auto p = std::make_unique<PPLNet>();
+  if (auto r = p->Init(args)) {
+    return p;
+  } else {
+    MMDEPLOY_ERROR("error creating PPLNet: {}", r.error().message().c_str());
+    return nullptr;
   }
-};
+}
 
-REGISTER_MODULE(Net, PPLNetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (pplnn, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/rknn/rknn_net.cpp b/csrc/mmdeploy/net/rknn/rknn_net.cpp
index 204b1dc3e5..9851b7ba2b 100644
--- a/csrc/mmdeploy/net/rknn/rknn_net.cpp
+++ b/csrc/mmdeploy/net/rknn/rknn_net.cpp
@@ -264,26 +264,21 @@ Result<void> RKNNNet::Forward() {
   return success();
 }
 
-class RKNNNetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "rknn"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value& args) override {
-    try {
-      auto p = std::make_unique<RKNNNet>();
-      if (auto r = p->Init(args)) {
-        return p;
-      } else {
-        MMDEPLOY_ERROR("error creating RKNNNet: {}", r.error().message().c_str());
-        return nullptr;
-      }
-    } catch (const std::exception& e) {
-      MMDEPLOY_ERROR("unhandled exception when creating RKNNNet: {}", e.what());
+static std::unique_ptr<Net> Create(const Value& args) {
+  try {
+    auto p = std::make_unique<RKNNNet>();
+    if (auto r = p->Init(args)) {
+      return p;
+    } else {
+      MMDEPLOY_ERROR("error creating RKNNNet: {}", r.error().message().c_str());
       return nullptr;
     }
+  } catch (const std::exception& e) {
+    MMDEPLOY_ERROR("unhandled exception when creating RKNNNet: {}", e.what());
+    return nullptr;
   }
-};
+}
 
-REGISTER_MODULE(Net, RKNNNetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (rknn, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/snpe/snpe_net.cpp b/csrc/mmdeploy/net/snpe/snpe_net.cpp
index fe7ce682e6..d847449652 100644
--- a/csrc/mmdeploy/net/snpe/snpe_net.cpp
+++ b/csrc/mmdeploy/net/snpe/snpe_net.cpp
@@ -242,21 +242,16 @@ Result<void> SNPENet::Forward() {
   return success();
 }
 
-class SNPENetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "snpe"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value& args) override {
-    auto p = std::make_unique<SNPENet>();
-    if (auto r = p->Init(args)) {
-      return p;
-    } else {
-      MMDEPLOY_ERROR("error creating SNPENet: {}", r.error().message().c_str());
-      return nullptr;
-    }
+static std::unique_ptr<Net> Create(const Value& args) {
+  auto p = std::make_unique<SNPENet>();
+  if (auto r = p->Init(args)) {
+    return p;
+  } else {
+    MMDEPLOY_ERROR("error creating SNPENet: {}", r.error().message().c_str());
+    return nullptr;
   }
-};
+}
 
-REGISTER_MODULE(Net, SNPENetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (snpe, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/torchscript/torch_net.cpp b/csrc/mmdeploy/net/torchscript/torch_net.cpp
index b98f013982..0f424bb710 100644
--- a/csrc/mmdeploy/net/torchscript/torch_net.cpp
+++ b/csrc/mmdeploy/net/torchscript/torch_net.cpp
@@ -218,20 +218,16 @@ Result<Tensor> TorchNet::FromTorchTensor(const torch::Tensor& tensor, const std:
   return Tensor(desc, std::shared_ptr<void>(tensor.data_ptr(), [tensor](auto) {}));
 }
 
-class TorchNetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "torchscript"; }
-  std::unique_ptr<Net> Create(const Value& cfg) override {
-    auto p = std::make_unique<TorchNet>();
-    if (auto status = p->Init(cfg)) {
-      return p;
-    } else {
-      MMDEPLOY_ERROR("Failed to created TorchNet with config: {}", cfg);
-    }
-    return nullptr;
+static std::unique_ptr<Net> Create(const Value& args) {
+  auto p = std::make_unique<TorchNet>();
+  if (auto status = p->Init(args)) {
+    return p;
+  } else {
+    MMDEPLOY_ERROR("Failed to created TorchNet with config: {}", args);
   }
-};
+  return nullptr;
+}
 
-REGISTER_MODULE(Net, TorchNetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (torchscript, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/net/trt/trt_net.cpp b/csrc/mmdeploy/net/trt/trt_net.cpp
index a2a8dad2dd..359ece60bb 100644
--- a/csrc/mmdeploy/net/trt/trt_net.cpp
+++ b/csrc/mmdeploy/net/trt/trt_net.cpp
@@ -210,19 +210,14 @@ Result<void> TRTNet::Forward() {
 
 Result<void> TRTNet::ForwardAsync(Event* event) { return Status(eNotSupported); }
 
-class TRTNetCreator : public Creator<Net> {
- public:
-  const char* GetName() const override { return "tensorrt"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Net> Create(const Value& args) override {
-    auto p = std::make_unique<TRTNet>();
-    if (p->Init(args)) {
-      return p;
-    }
-    return nullptr;
+static std::unique_ptr<Net> Create(const Value& args) {
+  auto p = std::make_unique<TRTNet>();
+  if (p->Init(args)) {
+    return p;
   }
-};
+  return nullptr;
+}
 
-REGISTER_MODULE(Net, TRTNetCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Net, (tensorrt, 0), Create);
 
 }  // namespace mmdeploy::framework
diff --git a/csrc/mmdeploy/preprocess/cpu/collect_impl.cpp b/csrc/mmdeploy/preprocess/cpu/collect_impl.cpp
index a5eab40724..01e7a1d49d 100644
--- a/csrc/mmdeploy/preprocess/cpu/collect_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/collect_impl.cpp
@@ -2,8 +2,7 @@
 
 #include "mmdeploy/preprocess/transform/collect.h"
 
-namespace mmdeploy {
-namespace cpu {
+namespace mmdeploy::cpu {
 
 class CollectImpl : public ::mmdeploy::CollectImpl {
  public:
@@ -11,18 +10,6 @@ class CollectImpl : public ::mmdeploy::CollectImpl {
   ~CollectImpl() = default;
 };
 
-class CollectImplCreator : public Creator<::mmdeploy::CollectImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  std::unique_ptr<::mmdeploy::CollectImpl> Create(const Value& args) override {
-    return std::make_unique<CollectImpl>(args);
-  }
-};
-
-}  // namespace cpu
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::CollectImpl, (cpu, 0), CollectImpl);
 
-using mmdeploy::CollectImpl;
-using mmdeploy::cpu::CollectImplCreator;
-REGISTER_MODULE(CollectImpl, CollectImplCreator);
+}  // namespace mmdeploy::cpu
diff --git a/csrc/mmdeploy/preprocess/cpu/crop_impl.cpp b/csrc/mmdeploy/preprocess/cpu/crop_impl.cpp
index 1935771ab1..82dbca69ae 100644
--- a/csrc/mmdeploy/preprocess/cpu/crop_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/crop_impl.cpp
@@ -6,8 +6,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace cpu {
+namespace mmdeploy::cpu {
 
 class CenterCropImpl : public ::mmdeploy::CenterCropImpl {
  public:
@@ -26,17 +25,6 @@ class CenterCropImpl : public ::mmdeploy::CenterCropImpl {
   }
 };
 
-class CenterCropImplCreator : public Creator<::mmdeploy::CenterCropImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<CenterCropImpl>(args); }
-};
-
-}  // namespace cpu
-}  // namespace mmdeploy
-
-using ::mmdeploy::CenterCropImpl;
-using ::mmdeploy::cpu::CenterCropImplCreator;
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::CenterCropImpl, (cpu, 0), CenterCropImpl);
 
-REGISTER_MODULE(CenterCropImpl, CenterCropImplCreator);
+}  // namespace mmdeploy::cpu
diff --git a/csrc/mmdeploy/preprocess/cpu/default_format_bundle_impl.cpp b/csrc/mmdeploy/preprocess/cpu/default_format_bundle_impl.cpp
index cdb7f75c17..fa75e380ec 100644
--- a/csrc/mmdeploy/preprocess/cpu/default_format_bundle_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/default_format_bundle_impl.cpp
@@ -4,8 +4,7 @@
 #include "mmdeploy/preprocess/transform/default_format_bundle.h"
 #include "opencv_utils.h"
 
-namespace mmdeploy {
-namespace cpu {
+namespace mmdeploy::cpu {
 
 class DefaultFormatBundleImpl : public ::mmdeploy::DefaultFormatBundleImpl {
  public:
@@ -47,18 +46,7 @@ class DefaultFormatBundleImpl : public ::mmdeploy::DefaultFormatBundleImpl {
   }
 };
 
-class DefaultFormatBundleImplCreator : public Creator<::mmdeploy::DefaultFormatBundleImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<DefaultFormatBundleImpl>(args);
-  }
-};
-
-}  // namespace cpu
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::DefaultFormatBundleImpl, (cpu, 0),
+                                 DefaultFormatBundleImpl);
 
-using mmdeploy::DefaultFormatBundleImpl;
-using mmdeploy::cpu::DefaultFormatBundleImplCreator;
-REGISTER_MODULE(DefaultFormatBundleImpl, DefaultFormatBundleImplCreator);
+}  // namespace mmdeploy::cpu
diff --git a/csrc/mmdeploy/preprocess/cpu/image2tensor_impl.cpp b/csrc/mmdeploy/preprocess/cpu/image2tensor_impl.cpp
index 1f6a45897a..7a6e6a640f 100644
--- a/csrc/mmdeploy/preprocess/cpu/image2tensor_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/image2tensor_impl.cpp
@@ -4,8 +4,7 @@
 #include "mmdeploy/preprocess/transform/image2tensor.h"
 #include "opencv_utils.h"
 
-namespace mmdeploy {
-namespace cpu {
+namespace mmdeploy::cpu {
 
 class ImageToTensorImpl : public ::mmdeploy::ImageToTensorImpl {
  public:
@@ -31,18 +30,6 @@ class ImageToTensorImpl : public ::mmdeploy::ImageToTensorImpl {
   }
 };
 
-class ImageToTensorImplCreator : public Creator<::mmdeploy::ImageToTensorImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<ImageToTensorImpl>(args);
-  }
-};
-
-}  // namespace cpu
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::ImageToTensorImpl, (cpu, 0), ImageToTensorImpl);
 
-using mmdeploy::ImageToTensorImpl;
-using mmdeploy::cpu::ImageToTensorImplCreator;
-REGISTER_MODULE(ImageToTensorImpl, ImageToTensorImplCreator);
+}  // namespace mmdeploy::cpu
diff --git a/csrc/mmdeploy/preprocess/cpu/load_impl.cpp b/csrc/mmdeploy/preprocess/cpu/load_impl.cpp
index ce857eced4..dc49eb241f 100644
--- a/csrc/mmdeploy/preprocess/cpu/load_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/load_impl.cpp
@@ -5,8 +5,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace cpu {
+namespace mmdeploy::cpu {
 
 class PrepareImageImpl : public ::mmdeploy::PrepareImageImpl {
  public:
@@ -37,16 +36,6 @@ class PrepareImageImpl : public ::mmdeploy::PrepareImageImpl {
   }
 };
 
-class PrepareImageImplCreator : public Creator<::mmdeploy::PrepareImageImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<PrepareImageImpl>(args); }
-};
-
-}  // namespace cpu
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::PrepareImageImpl, (cpu, 0), PrepareImageImpl);
 
-using mmdeploy::PrepareImageImpl;
-using mmdeploy::cpu::PrepareImageImplCreator;
-REGISTER_MODULE(PrepareImageImpl, PrepareImageImplCreator);
+}  // namespace mmdeploy::cpu
diff --git a/csrc/mmdeploy/preprocess/cpu/normalize_impl.cpp b/csrc/mmdeploy/preprocess/cpu/normalize_impl.cpp
index 339293b7fc..57b8f27ca8 100644
--- a/csrc/mmdeploy/preprocess/cpu/normalize_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/normalize_impl.cpp
@@ -7,8 +7,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace cpu {
+namespace mmdeploy::cpu {
 
 class NormalizeImpl : public ::mmdeploy::NormalizeImpl {
  public:
@@ -35,18 +34,6 @@ class NormalizeImpl : public ::mmdeploy::NormalizeImpl {
   }
 };
 
-class NormalizeImplCreator : public Creator<::mmdeploy::NormalizeImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  std::unique_ptr<::mmdeploy::NormalizeImpl> Create(const Value& args) override {
-    return make_unique<NormalizeImpl>(args);
-  }
-};
-
-}  // namespace cpu
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::NormalizeImpl, (cpu, 0), NormalizeImpl);
 
-using mmdeploy::NormalizeImpl;
-using mmdeploy::cpu::NormalizeImplCreator;
-REGISTER_MODULE(NormalizeImpl, NormalizeImplCreator);
+}  // namespace mmdeploy::cpu
diff --git a/csrc/mmdeploy/preprocess/cpu/pad_impl.cpp b/csrc/mmdeploy/preprocess/cpu/pad_impl.cpp
index 0254def189..101948b83e 100644
--- a/csrc/mmdeploy/preprocess/cpu/pad_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/pad_impl.cpp
@@ -6,8 +6,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace cpu {
+namespace mmdeploy::cpu {
 
 class PadImpl : public ::mmdeploy::PadImpl {
  public:
@@ -38,16 +37,6 @@ class PadImpl : public ::mmdeploy::PadImpl {
   int border_type_;
 };
 
-class PadImplCreator : public Creator<::mmdeploy::PadImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<PadImpl>(args); }
-};
-
-}  // namespace cpu
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::PadImpl, (cpu, 0), PadImpl);
 
-using mmdeploy::PadImpl;
-using mmdeploy::cpu::PadImplCreator;
-REGISTER_MODULE(PadImpl, PadImplCreator);
+}  // namespace mmdeploy::cpu
diff --git a/csrc/mmdeploy/preprocess/cpu/resize_impl.cpp b/csrc/mmdeploy/preprocess/cpu/resize_impl.cpp
index e44fc5188a..9cfe5260b5 100644
--- a/csrc/mmdeploy/preprocess/cpu/resize_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/resize_impl.cpp
@@ -8,8 +8,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace cpu {
+namespace mmdeploy::cpu {
 
 class ResizeImpl final : public ::mmdeploy::ResizeImpl {
  public:
@@ -29,16 +28,6 @@ class ResizeImpl final : public ::mmdeploy::ResizeImpl {
   }
 };
 
-class ResizeImplCreator : public Creator<mmdeploy::ResizeImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return std::make_unique<ResizeImpl>(args); }
-};
-
-}  // namespace cpu
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::ResizeImpl, (cpu, 0), ResizeImpl);
 
-using mmdeploy::ResizeImpl;
-using mmdeploy::cpu::ResizeImplCreator;
-REGISTER_MODULE(ResizeImpl, ResizeImplCreator);
+}  // namespace mmdeploy::cpu
diff --git a/csrc/mmdeploy/preprocess/cpu/ten_crop_impl.cpp b/csrc/mmdeploy/preprocess/cpu/ten_crop_impl.cpp
index bcb093dcde..015c2c0860 100644
--- a/csrc/mmdeploy/preprocess/cpu/ten_crop_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/ten_crop_impl.cpp
@@ -32,16 +32,7 @@ class TenCropImpl : public ::mmdeploy::TenCropImpl {
   }
 };
 
-class TenCropImplCreator : public Creator<::mmdeploy::TenCropImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<TenCropImpl>(args); }
-};
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::TenCropImpl, (cpu, 0), TenCropImpl);
 
 }  // namespace cpu
 }  // namespace mmdeploy
-
-using ::mmdeploy::TenCropImpl;
-using ::mmdeploy::cpu::TenCropImplCreator;
-REGISTER_MODULE(TenCropImpl, TenCropImplCreator);
diff --git a/csrc/mmdeploy/preprocess/cpu/three_crop_impl.cpp b/csrc/mmdeploy/preprocess/cpu/three_crop_impl.cpp
index f3c3909373..cb54f6c048 100644
--- a/csrc/mmdeploy/preprocess/cpu/three_crop_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cpu/three_crop_impl.cpp
@@ -23,16 +23,7 @@ class ThreeCropImpl : public ::mmdeploy::ThreeCropImpl {
   }
 };
 
-class ThreeCropImplCreator : public Creator<::mmdeploy::ThreeCropImpl> {
- public:
-  const char* GetName() const override { return "cpu"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<ThreeCropImpl>(args); }
-};
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::ThreeCropImpl, (cpu, 0), ThreeCropImpl);
 
 }  // namespace cpu
 }  // namespace mmdeploy
-
-using ::mmdeploy::ThreeCropImpl;
-using ::mmdeploy::cpu::ThreeCropImplCreator;
-REGISTER_MODULE(ThreeCropImpl, ThreeCropImplCreator);
diff --git a/csrc/mmdeploy/preprocess/cuda/collect_impl.cpp b/csrc/mmdeploy/preprocess/cuda/collect_impl.cpp
index 28693e9351..f2b84354a7 100644
--- a/csrc/mmdeploy/preprocess/cuda/collect_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/collect_impl.cpp
@@ -2,8 +2,7 @@
 
 #include "mmdeploy/preprocess/transform/collect.h"
 
-namespace mmdeploy {
-namespace cuda {
+namespace mmdeploy::cuda {
 
 class CollectImpl : public ::mmdeploy::CollectImpl {
  public:
@@ -11,18 +10,6 @@ class CollectImpl : public ::mmdeploy::CollectImpl {
   ~CollectImpl() = default;
 };
 
-class CollectImplCreator : public Creator<::mmdeploy::CollectImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  std::unique_ptr<::mmdeploy::CollectImpl> Create(const Value& args) override {
-    return std::make_unique<CollectImpl>(args);
-  }
-};
-
-}  // namespace cuda
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::CollectImpl, (cuda, 0), CollectImpl);
 
-using mmdeploy::CollectImpl;
-using mmdeploy::cuda::CollectImplCreator;
-REGISTER_MODULE(CollectImpl, CollectImplCreator);
+}  // namespace mmdeploy::cuda
diff --git a/csrc/mmdeploy/preprocess/cuda/crop_impl.cpp b/csrc/mmdeploy/preprocess/cuda/crop_impl.cpp
index ec207d85a6..2c81dd59a9 100644
--- a/csrc/mmdeploy/preprocess/cuda/crop_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/crop_impl.cpp
@@ -7,8 +7,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace cuda {
+namespace mmdeploy::cuda {
 
 template <typename T, int channels>
 void Crop(const T* src, int src_w, T* dst, int dst_h, int dst_w, int offset_h, int offset_w,
@@ -67,19 +66,6 @@ class CenterCropImpl : public ::mmdeploy::CenterCropImpl {
   }
 };
 
-class CenterCropImplCreator : public Creator<::mmdeploy::CenterCropImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<CenterCropImpl>(args); }
-
- private:
-  int version_{1};
-};
-
-}  // namespace cuda
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::CenterCropImpl, (cuda, 0), CenterCropImpl);
 
-using ::mmdeploy::CenterCropImpl;
-using ::mmdeploy::cuda::CenterCropImplCreator;
-REGISTER_MODULE(CenterCropImpl, CenterCropImplCreator);
+}  // namespace mmdeploy::cuda
diff --git a/csrc/mmdeploy/preprocess/cuda/default_format_bundle_impl.cpp b/csrc/mmdeploy/preprocess/cuda/default_format_bundle_impl.cpp
index 848dab921d..874aea26e2 100644
--- a/csrc/mmdeploy/preprocess/cuda/default_format_bundle_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/default_format_bundle_impl.cpp
@@ -5,8 +5,7 @@
 #include "mmdeploy/core/utils/device_utils.h"
 #include "mmdeploy/preprocess/transform/default_format_bundle.h"
 
-namespace mmdeploy {
-namespace cuda {
+namespace mmdeploy::cuda {
 
 template <int channels>
 void CastToFloat(const uint8_t* src, int height, int width, float* dst, cudaStream_t stream);
@@ -76,18 +75,7 @@ class DefaultFormatBundleImpl final : public ::mmdeploy::DefaultFormatBundleImpl
   }
 };
 
-class DefaultFormatBundleImplCreator : public Creator<::mmdeploy::DefaultFormatBundleImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& cfg) override {
-    return std::make_unique<DefaultFormatBundleImpl>(cfg);
-  }
-};
-
-}  // namespace cuda
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::DefaultFormatBundleImpl, (cuda, 0),
+                                 DefaultFormatBundleImpl);
 
-using ::mmdeploy::DefaultFormatBundleImpl;
-using ::mmdeploy::cuda::DefaultFormatBundleImplCreator;
-REGISTER_MODULE(DefaultFormatBundleImpl, DefaultFormatBundleImplCreator);
+}  // namespace mmdeploy::cuda
diff --git a/csrc/mmdeploy/preprocess/cuda/image2tensor_impl.cpp b/csrc/mmdeploy/preprocess/cuda/image2tensor_impl.cpp
index 60bd44ba3a..c8a23fa8a4 100644
--- a/csrc/mmdeploy/preprocess/cuda/image2tensor_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/image2tensor_impl.cpp
@@ -5,8 +5,7 @@
 #include "mmdeploy/core/utils/device_utils.h"
 #include "mmdeploy/preprocess/transform/image2tensor.h"
 
-namespace mmdeploy {
-namespace cuda {
+namespace mmdeploy::cuda {
 
 template <typename T>
 void Transpose(const T* src, int height, int width, int channels, T* dst, cudaStream_t stream);
@@ -46,16 +45,6 @@ class ImageToTensorImpl final : public ::mmdeploy::ImageToTensorImpl {
   }
 };
 
-class ImageToTensorImplCreator : public Creator<::mmdeploy::ImageToTensorImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& cfg) override { return std::make_unique<ImageToTensorImpl>(cfg); }
-};
-
-}  // namespace cuda
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::ImageToTensorImpl, (cuda, 0), ImageToTensorImpl);
 
-using ::mmdeploy::ImageToTensorImpl;
-using ::mmdeploy::cuda::ImageToTensorImplCreator;
-REGISTER_MODULE(ImageToTensorImpl, ImageToTensorImplCreator);
+}  // namespace mmdeploy::cuda
diff --git a/csrc/mmdeploy/preprocess/cuda/load_impl.cpp b/csrc/mmdeploy/preprocess/cuda/load_impl.cpp
index b4f0f09397..524cc1f2d8 100644
--- a/csrc/mmdeploy/preprocess/cuda/load_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/load_impl.cpp
@@ -10,8 +10,7 @@
 using namespace std;
 using namespace ppl::cv::cuda;
 
-namespace mmdeploy {
-namespace cuda {
+namespace mmdeploy::cuda {
 
 template <int channels>
 void CastToFloat(const uint8_t* src, int height, int width, float* dst, cudaStream_t stream);
@@ -163,16 +162,6 @@ class PrepareImageImpl : public ::mmdeploy::PrepareImageImpl {
   }
 };
 
-class PrepareImageImplCreator : public Creator<::mmdeploy::PrepareImageImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<PrepareImageImpl>(args); }
-};
-
-}  // namespace cuda
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::PrepareImageImpl, (cuda, 0), PrepareImageImpl);
 
-using mmdeploy::PrepareImageImpl;
-using mmdeploy::cuda::PrepareImageImplCreator;
-REGISTER_MODULE(PrepareImageImpl, PrepareImageImplCreator);
+}  // namespace mmdeploy::cuda
diff --git a/csrc/mmdeploy/preprocess/cuda/normalize_impl.cpp b/csrc/mmdeploy/preprocess/cuda/normalize_impl.cpp
index 4a480bf4d0..648a1f82fc 100644
--- a/csrc/mmdeploy/preprocess/cuda/normalize_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/normalize_impl.cpp
@@ -89,17 +89,6 @@ class NormalizeImpl : public ::mmdeploy::NormalizeImpl {
   }
 };
 
-class NormalizeImplCreator : public Creator<::mmdeploy::NormalizeImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  std::unique_ptr<::mmdeploy::NormalizeImpl> Create(const Value& args) override {
-    return make_unique<NormalizeImpl>(args);
-  }
-};
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::NormalizeImpl, (cuda, 0), NormalizeImpl);
 
 }  // namespace mmdeploy::cuda
-
-using mmdeploy::NormalizeImpl;
-using mmdeploy::cuda::NormalizeImplCreator;
-REGISTER_MODULE(NormalizeImpl, NormalizeImplCreator);
diff --git a/csrc/mmdeploy/preprocess/cuda/pad_impl.cpp b/csrc/mmdeploy/preprocess/cuda/pad_impl.cpp
index 2ba4b315fc..0aec0cfb36 100644
--- a/csrc/mmdeploy/preprocess/cuda/pad_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/pad_impl.cpp
@@ -8,8 +8,7 @@
 using namespace std;
 using namespace ppl::cv::cuda;
 
-namespace mmdeploy {
-namespace cuda {
+namespace mmdeploy::cuda {
 
 class PadImpl : public ::mmdeploy::PadImpl {
  public:
@@ -94,17 +93,6 @@ class PadImpl : public ::mmdeploy::PadImpl {
   ppl::cv::BorderType padding_mode_;
 };
 
-class PadCreator : public Creator<::mmdeploy::PadImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<PadImpl>(args); }
-};
-
-}  // namespace cuda
-}  // namespace mmdeploy
-
-using ::mmdeploy::PadImpl;
-using mmdeploy::cuda::PadCreator;
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::PadImpl, (cuda, 0), PadImpl);
 
-REGISTER_MODULE(PadImpl, PadCreator);
+}  // namespace mmdeploy::cuda
diff --git a/csrc/mmdeploy/preprocess/cuda/resize_impl.cpp b/csrc/mmdeploy/preprocess/cuda/resize_impl.cpp
index 57c9d485de..7fa3e83518 100644
--- a/csrc/mmdeploy/preprocess/cuda/resize_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/resize_impl.cpp
@@ -7,8 +7,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace cuda {
+namespace mmdeploy::cuda {
 
 class ResizeImpl final : public ::mmdeploy::ResizeImpl {
  public:
@@ -81,15 +80,6 @@ class ResizeImpl final : public ::mmdeploy::ResizeImpl {
   }
 };
 
-class ResizeImplCreator : public Creator<::mmdeploy::ResizeImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<ResizeImpl>(args); }
-};
-}  // namespace cuda
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::ResizeImpl, (cuda, 0), ResizeImpl);
 
-using ::mmdeploy::ResizeImpl;
-using ::mmdeploy::cuda::ResizeImplCreator;
-REGISTER_MODULE(ResizeImpl, ResizeImplCreator);
+}  // namespace mmdeploy::cuda
diff --git a/csrc/mmdeploy/preprocess/cuda/ten_crop_impl.cpp b/csrc/mmdeploy/preprocess/cuda/ten_crop_impl.cpp
index 65972e0691..069960b09d 100644
--- a/csrc/mmdeploy/preprocess/cuda/ten_crop_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/ten_crop_impl.cpp
@@ -71,19 +71,7 @@ class TenCropImpl : public ::mmdeploy::TenCropImpl {
   }
 };
 
-class TenCropImplCreator : public Creator<::mmdeploy::TenCropImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<TenCropImpl>(args); }
-
- private:
-  int version_{1};
-};
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::TenCropImpl, (cuda, 0), TenCropImpl);
 
 }  // namespace cuda
 }  // namespace mmdeploy
-
-using ::mmdeploy::TenCropImpl;
-using ::mmdeploy::cuda::TenCropImplCreator;
-REGISTER_MODULE(TenCropImpl, TenCropImplCreator);
diff --git a/csrc/mmdeploy/preprocess/cuda/three_crop_impl.cpp b/csrc/mmdeploy/preprocess/cuda/three_crop_impl.cpp
index ac6ad374ad..bf792cbf35 100644
--- a/csrc/mmdeploy/preprocess/cuda/three_crop_impl.cpp
+++ b/csrc/mmdeploy/preprocess/cuda/three_crop_impl.cpp
@@ -24,19 +24,7 @@ class ThreeCropImpl : public ::mmdeploy::ThreeCropImpl {
   }
 };
 
-class ThreeCropImplCreator : public Creator<::mmdeploy::ThreeCropImpl> {
- public:
-  const char* GetName() const override { return "cuda"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<ThreeCropImpl>(args); }
-
- private:
-  int version_{1};
-};
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::ThreeCropImpl, (cuda, 0), ThreeCropImpl);
 
 }  // namespace cuda
 }  // namespace mmdeploy
-
-using ::mmdeploy::ThreeCropImpl;
-using ::mmdeploy::cuda::ThreeCropImplCreator;
-REGISTER_MODULE(ThreeCropImpl, ThreeCropImplCreator);
diff --git a/csrc/mmdeploy/preprocess/elena/collect_impl.cpp b/csrc/mmdeploy/preprocess/elena/collect_impl.cpp
index 27e29fdd4d..ef5bd31939 100644
--- a/csrc/mmdeploy/preprocess/elena/collect_impl.cpp
+++ b/csrc/mmdeploy/preprocess/elena/collect_impl.cpp
@@ -12,8 +12,7 @@
 #include "mmdeploy/preprocess/transform/collect.h"
 #include "mmdeploy/preprocess/transform/tracer.h"
 
-namespace mmdeploy {
-namespace elena {
+namespace mmdeploy::elena {
 
 using namespace trace;
 
@@ -128,18 +127,6 @@ class CollectImpl : public ::mmdeploy::CollectImpl {
   std::string device_name_;
 };
 
-class CollectImplCreator : public Creator<::mmdeploy::CollectImpl> {
- public:
-  const char* GetName() const override { return "elena"; }
-  int GetVersion() const override { return 1; }
-  std::unique_ptr<::mmdeploy::CollectImpl> Create(const Value& args) override {
-    return std::make_unique<CollectImpl>(args);
-  }
-};
-
-}  // namespace elena
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::CollectImpl, (elena, 0), CollectImpl);
 
-using mmdeploy::CollectImpl;
-using mmdeploy::elena::CollectImplCreator;
-REGISTER_MODULE(CollectImpl, CollectImplCreator);
+}  // namespace mmdeploy::elena
diff --git a/csrc/mmdeploy/preprocess/elena/crop_impl.cpp b/csrc/mmdeploy/preprocess/elena/crop_impl.cpp
index 87c938ff5f..9032ea5a92 100644
--- a/csrc/mmdeploy/preprocess/elena/crop_impl.cpp
+++ b/csrc/mmdeploy/preprocess/elena/crop_impl.cpp
@@ -4,8 +4,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace elena {
+namespace mmdeploy::elena {
 
 class CenterCropImpl : public ::mmdeploy::CenterCropImpl {
  public:
@@ -28,17 +27,6 @@ class CenterCropImpl : public ::mmdeploy::CenterCropImpl {
   Buffer dummy_buffer_{Device{"cpu"}, 0, nullptr};
 };
 
-class CenterCropImplCreator : public Creator<::mmdeploy::CenterCropImpl> {
- public:
-  const char* GetName() const override { return "elena"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<CenterCropImpl>(args); }
-};
-
-}  // namespace elena
-}  // namespace mmdeploy
-
-using ::mmdeploy::CenterCropImpl;
-using ::mmdeploy::elena::CenterCropImplCreator;
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::CenterCropImpl, (elena, 0), CenterCropImpl);
 
-REGISTER_MODULE(CenterCropImpl, CenterCropImplCreator);
+}  // namespace mmdeploy::elena
diff --git a/csrc/mmdeploy/preprocess/elena/default_format_bundle_impl.cpp b/csrc/mmdeploy/preprocess/elena/default_format_bundle_impl.cpp
index 15f606c124..8246f6cddd 100644
--- a/csrc/mmdeploy/preprocess/elena/default_format_bundle_impl.cpp
+++ b/csrc/mmdeploy/preprocess/elena/default_format_bundle_impl.cpp
@@ -2,8 +2,7 @@
 
 #include "mmdeploy/preprocess/transform/default_format_bundle.h"
 
-namespace mmdeploy {
-namespace elena {
+namespace mmdeploy::elena {
 
 class DefaultFormatBundleImpl : public ::mmdeploy::DefaultFormatBundleImpl {
  public:
@@ -39,18 +38,7 @@ class DefaultFormatBundleImpl : public ::mmdeploy::DefaultFormatBundleImpl {
   Buffer dummy_buffer_{Device{"cpu"}, 0, nullptr};
 };
 
-class DefaultFormatBundleImplCreator : public Creator<::mmdeploy::DefaultFormatBundleImpl> {
- public:
-  const char* GetName() const override { return "elena"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<DefaultFormatBundleImpl>(args);
-  }
-};
-
-}  // namespace elena
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::DefaultFormatBundleImpl, (elena, 0),
+                                 DefaultFormatBundleImpl);
 
-using mmdeploy::DefaultFormatBundleImpl;
-using mmdeploy::elena::DefaultFormatBundleImplCreator;
-REGISTER_MODULE(DefaultFormatBundleImpl, DefaultFormatBundleImplCreator);
+}  // namespace mmdeploy::elena
diff --git a/csrc/mmdeploy/preprocess/elena/image2tensor_impl.cpp b/csrc/mmdeploy/preprocess/elena/image2tensor_impl.cpp
index 371aa46236..c05a3eed84 100644
--- a/csrc/mmdeploy/preprocess/elena/image2tensor_impl.cpp
+++ b/csrc/mmdeploy/preprocess/elena/image2tensor_impl.cpp
@@ -2,8 +2,7 @@
 
 #include "mmdeploy/preprocess/transform/image2tensor.h"
 
-namespace mmdeploy {
-namespace elena {
+namespace mmdeploy::elena {
 
 class ImageToTensorImpl : public ::mmdeploy::ImageToTensorImpl {
  public:
@@ -24,18 +23,6 @@ class ImageToTensorImpl : public ::mmdeploy::ImageToTensorImpl {
   Buffer dummy_buffer_{Device{"cpu"}, 0, nullptr};
 };
 
-class ImageToTensorImplCreator : public Creator<::mmdeploy::ImageToTensorImpl> {
- public:
-  const char* GetName() const override { return "elena"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<ImageToTensorImpl>(args);
-  }
-};
-
-}  // namespace elena
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::ImageToTensorImpl, (elena, 0), ImageToTensorImpl);
 
-using mmdeploy::ImageToTensorImpl;
-using mmdeploy::elena::ImageToTensorImplCreator;
-REGISTER_MODULE(ImageToTensorImpl, ImageToTensorImplCreator);
+}  // namespace mmdeploy::elena
diff --git a/csrc/mmdeploy/preprocess/elena/load_impl.cpp b/csrc/mmdeploy/preprocess/elena/load_impl.cpp
index 7be21c07a3..5c7945c9ed 100644
--- a/csrc/mmdeploy/preprocess/elena/load_impl.cpp
+++ b/csrc/mmdeploy/preprocess/elena/load_impl.cpp
@@ -4,8 +4,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace elena {
+namespace mmdeploy::elena {
 
 class PrepareImageImpl : public ::mmdeploy::PrepareImageImpl {
  public:
@@ -53,16 +52,6 @@ class PrepareImageImpl : public ::mmdeploy::PrepareImageImpl {
   Buffer dummy_buffer_{Device{"cpu"}, 0, nullptr};
 };
 
-class PrepareImageImplCreator : public Creator<::mmdeploy::PrepareImageImpl> {
- public:
-  const char* GetName() const override { return "elena"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<PrepareImageImpl>(args); }
-};
-
-}  // namespace elena
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::PrepareImageImpl, (elena, 0), PrepareImageImpl);
 
-using mmdeploy::PrepareImageImpl;
-using mmdeploy::elena::PrepareImageImplCreator;
-REGISTER_MODULE(PrepareImageImpl, PrepareImageImplCreator);
+}  // namespace mmdeploy::elena
diff --git a/csrc/mmdeploy/preprocess/elena/normalize_impl.cpp b/csrc/mmdeploy/preprocess/elena/normalize_impl.cpp
index 7835ca1afb..f3bda349b8 100644
--- a/csrc/mmdeploy/preprocess/elena/normalize_impl.cpp
+++ b/csrc/mmdeploy/preprocess/elena/normalize_impl.cpp
@@ -4,8 +4,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace elena {
+namespace mmdeploy::elena {
 
 class NormalizeImpl : public ::mmdeploy::NormalizeImpl {
  public:
@@ -26,18 +25,6 @@ class NormalizeImpl : public ::mmdeploy::NormalizeImpl {
   Buffer dummy_buffer_{Device{"cpu"}, 0, nullptr};
 };
 
-class NormalizeImplCreator : public Creator<::mmdeploy::NormalizeImpl> {
- public:
-  const char* GetName() const override { return "elena"; }
-  int GetVersion() const override { return 1; }
-  std::unique_ptr<::mmdeploy::NormalizeImpl> Create(const Value& args) override {
-    return make_unique<NormalizeImpl>(args);
-  }
-};
-
-}  // namespace elena
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::NormalizeImpl, (elena, 0), NormalizeImpl);
 
-using mmdeploy::NormalizeImpl;
-using mmdeploy::elena::NormalizeImplCreator;
-REGISTER_MODULE(NormalizeImpl, NormalizeImplCreator);
+}  // namespace mmdeploy::elena
diff --git a/csrc/mmdeploy/preprocess/elena/pad_impl.cpp b/csrc/mmdeploy/preprocess/elena/pad_impl.cpp
index 435b8948ab..0215fee884 100644
--- a/csrc/mmdeploy/preprocess/elena/pad_impl.cpp
+++ b/csrc/mmdeploy/preprocess/elena/pad_impl.cpp
@@ -4,8 +4,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace elena {
+namespace mmdeploy::elena {
 
 class PadImpl : public ::mmdeploy::PadImpl {
  public:
@@ -27,16 +26,6 @@ class PadImpl : public ::mmdeploy::PadImpl {
   Buffer dummy_buffer_{Device{"cpu"}, 0, nullptr};
 };
 
-class PadImplCreator : public Creator<::mmdeploy::PadImpl> {
- public:
-  const char* GetName() const override { return "elena"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return make_unique<PadImpl>(args); }
-};
-
-}  // namespace elena
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::PadImpl, (elena, 0), PadImpl);
 
-using mmdeploy::PadImpl;
-using mmdeploy::elena::PadImplCreator;
-REGISTER_MODULE(PadImpl, PadImplCreator);
+}  // namespace mmdeploy::elena
diff --git a/csrc/mmdeploy/preprocess/elena/resize_impl.cpp b/csrc/mmdeploy/preprocess/elena/resize_impl.cpp
index ecc3baed48..99286a671f 100644
--- a/csrc/mmdeploy/preprocess/elena/resize_impl.cpp
+++ b/csrc/mmdeploy/preprocess/elena/resize_impl.cpp
@@ -4,8 +4,7 @@
 
 using namespace std;
 
-namespace mmdeploy {
-namespace elena {
+namespace mmdeploy::elena {
 
 class ResizeImpl final : public ::mmdeploy::ResizeImpl {
  public:
@@ -26,16 +25,6 @@ class ResizeImpl final : public ::mmdeploy::ResizeImpl {
   Buffer dummy_buffer_{Device{"cpu"}, 0, nullptr};
 };
 
-class ResizeImplCreator : public Creator<mmdeploy::ResizeImpl> {
- public:
-  const char* GetName() const override { return "elena"; }
-  int GetVersion() const override { return 1; }
-  ReturnType Create(const Value& args) override { return std::make_unique<ResizeImpl>(args); }
-};
-
-}  // namespace elena
-}  // namespace mmdeploy
+MMDEPLOY_REGISTER_TRANSFORM_IMPL(::mmdeploy::ResizeImpl, (elena, 0), ResizeImpl);
 
-using mmdeploy::ResizeImpl;
-using mmdeploy::elena::ResizeImplCreator;
-REGISTER_MODULE(ResizeImpl, ResizeImplCreator);
+}  // namespace mmdeploy::elena
diff --git a/csrc/mmdeploy/preprocess/transform/collect.cpp b/csrc/mmdeploy/preprocess/transform/collect.cpp
index 4363822233..048cd09529 100644
--- a/csrc/mmdeploy/preprocess/transform/collect.cpp
+++ b/csrc/mmdeploy/preprocess/transform/collect.cpp
@@ -57,7 +57,7 @@ Result<Value> CollectImpl::Process(const Value &input) {
 }
 
 Collect::Collect(const Value &args, int version) : Transform(args) {
-  auto impl_creator = Registry<CollectImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<CollectImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'Collect' is not supported on '{}' platform", specified_platform_);
     throw_exception(eEntryNotFound);
@@ -67,19 +67,9 @@ Collect::Collect(const Value &args, int version) : Transform(args) {
 
 Result<Value> Collect::Process(const Value &input) { return impl_->Process(input); }
 
-class CollectCreator : public Creator<Transform> {
- public:
-  const char *GetName() const override { return "Collect"; }
-  int GetVersion() const override { return version_; }
-  ReturnType Create(const Value &args) override {
-    return std::make_unique<Collect>(args, version_);
-  }
-
- private:
-  int version_{1};
-};
-
-REGISTER_MODULE(Transform, CollectCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (Collect, 0), [](const Value &config) {
+  return std::make_unique<Collect>(config, 0);
+});
 
 MMDEPLOY_DEFINE_REGISTRY(CollectImpl);
 
diff --git a/csrc/mmdeploy/preprocess/transform/collect.h b/csrc/mmdeploy/preprocess/transform/collect.h
index 380f5f6788..7eee1baaa5 100644
--- a/csrc/mmdeploy/preprocess/transform/collect.h
+++ b/csrc/mmdeploy/preprocess/transform/collect.h
@@ -35,7 +35,7 @@ class MMDEPLOY_API Collect : public Transform {
   std::unique_ptr<CollectImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(CollectImpl);
+MMDEPLOY_DECLARE_REGISTRY(CollectImpl, std::unique_ptr<CollectImpl>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/preprocess/transform/compose.cpp b/csrc/mmdeploy/preprocess/transform/compose.cpp
index 77dd5109d3..67566f52bd 100644
--- a/csrc/mmdeploy/preprocess/transform/compose.cpp
+++ b/csrc/mmdeploy/preprocess/transform/compose.cpp
@@ -39,10 +39,10 @@ Compose::Compose(const Value& args, int version) : Transform(args) {
     cfg["context"] = context;
     auto type = cfg.value("type", std::string{});
     MMDEPLOY_DEBUG("creating transform: {} with cfg: {}", type, mmdeploy::to_json(cfg).dump(2));
-    auto creator = Registry<Transform>::Get().GetCreator(type, version);
+    auto creator = gRegistry<Transform>().Get(type, version);
     if (!creator) {
       MMDEPLOY_ERROR("Unable to find Transform creator: {}. Available transforms: {}", type,
-                     Registry<Transform>::Get().List());
+                     gRegistry<Transform>().List());
       throw_exception(eEntryNotFound);
     }
     auto transform = creator->Create(cfg);
@@ -66,17 +66,8 @@ Result<Value> Compose::Process(const Value& input) {
   return std::move(output);
 }
 
-class ComposeCreator : public Creator<Transform> {
- public:
-  const char* GetName() const override { return "Compose"; }
-  int GetVersion() const override { return version_; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<Compose>(args, version_);
-  }
-
- private:
-  int version_{1};
-};
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (Compose, 0), [](const Value& config) {
+  return std::make_unique<Compose>(config, 0);
+});
 
-REGISTER_MODULE(Transform, ComposeCreator);
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/preprocess/transform/crop.cpp b/csrc/mmdeploy/preprocess/transform/crop.cpp
index 831f12716c..b0d96380e7 100644
--- a/csrc/mmdeploy/preprocess/transform/crop.cpp
+++ b/csrc/mmdeploy/preprocess/transform/crop.cpp
@@ -77,7 +77,7 @@ Result<Value> CenterCropImpl::Process(const Value& input) {
 }
 
 CenterCrop::CenterCrop(const Value& args, int version) : Transform(args) {
-  auto impl_creator = Registry<CenterCropImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<CenterCropImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'CenterCrop' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'Resize' is not supported on specified platform");
@@ -85,16 +85,9 @@ CenterCrop::CenterCrop(const Value& args, int version) : Transform(args) {
   impl_ = impl_creator->Create(args);
 }
 
-class CenterCropCreator : public Creator<Transform> {
- public:
-  const char* GetName(void) const override { return "CenterCrop"; }
-  int GetVersion(void) const override { return version_; }
-  ReturnType Create(const Value& args) override { return make_unique<CenterCrop>(args, version_); }
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (CenterCrop, 0), [](const Value& config) {
+  return std::make_unique<CenterCrop>(config, 0);
+});
 
- private:
-  int version_{1};
-};
-
-REGISTER_MODULE(Transform, CenterCropCreator);
 MMDEPLOY_DEFINE_REGISTRY(CenterCropImpl);
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/preprocess/transform/crop.h b/csrc/mmdeploy/preprocess/transform/crop.h
index 1829860641..8960c9adac 100644
--- a/csrc/mmdeploy/preprocess/transform/crop.h
+++ b/csrc/mmdeploy/preprocess/transform/crop.h
@@ -42,7 +42,7 @@ class MMDEPLOY_API CenterCrop : public Transform {
   std::unique_ptr<CenterCropImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(CenterCropImpl);
+MMDEPLOY_DECLARE_REGISTRY(CenterCropImpl, std::unique_ptr<CenterCropImpl>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/preprocess/transform/default_format_bundle.cpp b/csrc/mmdeploy/preprocess/transform/default_format_bundle.cpp
index 24cb29bfa2..f948417523 100644
--- a/csrc/mmdeploy/preprocess/transform/default_format_bundle.cpp
+++ b/csrc/mmdeploy/preprocess/transform/default_format_bundle.cpp
@@ -59,8 +59,7 @@ Result<Value> DefaultFormatBundleImpl::Process(const Value& input) {
 }
 
 DefaultFormatBundle::DefaultFormatBundle(const Value& args, int version) : Transform(args) {
-  auto impl_creator =
-      Registry<DefaultFormatBundleImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<DefaultFormatBundleImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'DefaultFormatBundle' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'DefaultFormatBundle' is not supported on specified platform");
@@ -68,17 +67,9 @@ DefaultFormatBundle::DefaultFormatBundle(const Value& args, int version) : Trans
   impl_ = impl_creator->Create(args);
 }
 
-class DefaultFormatBundleCreator : public Creator<Transform> {
- public:
-  const char* GetName() const override { return "DefaultFormatBundle"; }
-  int GetVersion() const override { return version_; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<DefaultFormatBundle>(args, version_);
-  }
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (DefaultFormatBundle, 0), [](const Value& config) {
+  return std::make_unique<DefaultFormatBundle>(config, 0);
+});
 
- private:
-  int version_{1};
-};
-REGISTER_MODULE(Transform, DefaultFormatBundleCreator);
 MMDEPLOY_DEFINE_REGISTRY(DefaultFormatBundleImpl);
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/preprocess/transform/default_format_bundle.h b/csrc/mmdeploy/preprocess/transform/default_format_bundle.h
index f43c373749..0eec010e25 100644
--- a/csrc/mmdeploy/preprocess/transform/default_format_bundle.h
+++ b/csrc/mmdeploy/preprocess/transform/default_format_bundle.h
@@ -42,7 +42,8 @@ class MMDEPLOY_API DefaultFormatBundle : public Transform {
   std::unique_ptr<DefaultFormatBundleImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(DefaultFormatBundleImpl);
+MMDEPLOY_DECLARE_REGISTRY(DefaultFormatBundleImpl,
+                          std::unique_ptr<DefaultFormatBundleImpl>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/preprocess/transform/image2tensor.cpp b/csrc/mmdeploy/preprocess/transform/image2tensor.cpp
index 850d4b3966..6373ab8305 100644
--- a/csrc/mmdeploy/preprocess/transform/image2tensor.cpp
+++ b/csrc/mmdeploy/preprocess/transform/image2tensor.cpp
@@ -39,7 +39,7 @@ Result<Value> ImageToTensorImpl::Process(const Value& input) {
 }
 
 ImageToTensor::ImageToTensor(const Value& args, int version) : Transform(args) {
-  auto impl_creator = Registry<ImageToTensorImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<ImageToTensorImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'ImageToTensor' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'ImageToTensor' is not supported on specified platform");
@@ -47,17 +47,10 @@ ImageToTensor::ImageToTensor(const Value& args, int version) : Transform(args) {
   impl_ = impl_creator->Create(args);
 }
 
-class ImageToTensorCreator : public Creator<Transform> {
- public:
-  const char* GetName() const override { return "ImageToTensor"; }
-  int GetVersion() const override { return version_; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<ImageToTensor>(args, version_);
-  }
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (ImageToTensor, 0), [](const Value& config) {
+  return std::make_unique<ImageToTensor>(config, 0);
+});
 
- private:
-  int version_{1};
-};
-REGISTER_MODULE(Transform, ImageToTensorCreator);
 MMDEPLOY_DEFINE_REGISTRY(ImageToTensorImpl);
+
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/preprocess/transform/image2tensor.h b/csrc/mmdeploy/preprocess/transform/image2tensor.h
index bc98918002..b95e46009d 100644
--- a/csrc/mmdeploy/preprocess/transform/image2tensor.h
+++ b/csrc/mmdeploy/preprocess/transform/image2tensor.h
@@ -45,7 +45,8 @@ class MMDEPLOY_API ImageToTensor : public Transform {
   std::unique_ptr<ImageToTensorImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(ImageToTensorImpl);
+MMDEPLOY_DECLARE_REGISTRY(ImageToTensorImpl,
+                          std::unique_ptr<ImageToTensorImpl>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/preprocess/transform/lift.cpp b/csrc/mmdeploy/preprocess/transform/lift.cpp
index 0381acfed7..addda6312d 100644
--- a/csrc/mmdeploy/preprocess/transform/lift.cpp
+++ b/csrc/mmdeploy/preprocess/transform/lift.cpp
@@ -9,10 +9,10 @@
 namespace mmdeploy {
 Lift::Lift(const Value& args, int version) : Transform(args) {
   std::string type = "Compose";
-  auto creator = Registry<Transform>::Get().GetCreator(type, version);
+  auto creator = gRegistry<Transform>().Get(type, version);
   if (!creator) {
     MMDEPLOY_ERROR("Unable to find Transform creator: {}. Available transforms: {}", type,
-                   Registry<Transform>::Get().List());
+                   gRegistry<Transform>().List());
     throw_exception(eEntryNotFound);
   }
   compose_ = creator->Create(args);
@@ -28,15 +28,8 @@ Result<Value> Lift::Process(const Value& input) {
   return std::move(output);
 }
 
-class LiftCreator : public Creator<Transform> {
- public:
-  const char* GetName() const override { return "Lift"; }
-  int GetVersion() const override { return version_; }
-  ReturnType Create(const Value& args) override { return std::make_unique<Lift>(args, version_); }
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (Lift, 0), [](const Value& config) {
+  return std::make_unique<Lift>(config, 0);
+});
 
- private:
-  int version_{1};
-};
-
-REGISTER_MODULE(Transform, LiftCreator);
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/preprocess/transform/load.cpp b/csrc/mmdeploy/preprocess/transform/load.cpp
index 46fb67b236..1a2558ebb5 100644
--- a/csrc/mmdeploy/preprocess/transform/load.cpp
+++ b/csrc/mmdeploy/preprocess/transform/load.cpp
@@ -66,7 +66,7 @@ Result<Value> PrepareImageImpl::Process(const Value& input) {
 }
 
 PrepareImage::PrepareImage(const Value& args, int version) : Transform(args) {
-  auto impl_creator = Registry<PrepareImageImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<PrepareImageImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'PrepareImage' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'PrepareImage' is not supported on specified platform");
@@ -74,22 +74,9 @@ PrepareImage::PrepareImage(const Value& args, int version) : Transform(args) {
   impl_ = impl_creator->Create(args);
 }
 
-class PrepareImageCreator : public Creator<Transform> {
- public:
-  PrepareImageCreator() = default;
-  ~PrepareImageCreator() = default;
-
-  const char* GetName() const override { return "LoadImageFromFile"; }
-  int GetVersion() const override { return version_; }
-  std::unique_ptr<Transform> Create(const Value& value) override {
-    return std::make_unique<PrepareImage>(value, version_);
-  }
-
- private:
-  int version_{1};
-};
-
-REGISTER_MODULE(Transform, PrepareImageCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (LoadImageFromFile, 0), [](const Value& config) {
+  return std::make_unique<PrepareImage>(config, 0);
+});
 
 MMDEPLOY_DEFINE_REGISTRY(PrepareImageImpl);
 
diff --git a/csrc/mmdeploy/preprocess/transform/load.h b/csrc/mmdeploy/preprocess/transform/load.h
index 985170d1e6..cd2af0e09f 100644
--- a/csrc/mmdeploy/preprocess/transform/load.h
+++ b/csrc/mmdeploy/preprocess/transform/load.h
@@ -40,7 +40,7 @@ class MMDEPLOY_API PrepareImage : public Transform {
   std::unique_ptr<PrepareImageImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(PrepareImageImpl);
+MMDEPLOY_DECLARE_REGISTRY(PrepareImageImpl, std::unique_ptr<PrepareImageImpl>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/preprocess/transform/normalize.cpp b/csrc/mmdeploy/preprocess/transform/normalize.cpp
index 0e81f8d3ee..7cd79010ca 100644
--- a/csrc/mmdeploy/preprocess/transform/normalize.cpp
+++ b/csrc/mmdeploy/preprocess/transform/normalize.cpp
@@ -105,7 +105,7 @@ Result<Value> NormalizeImpl::Process(const Value& input) {
 }
 
 Normalize::Normalize(const Value& args, int version) : Transform(args) {
-  auto impl_creator = Registry<NormalizeImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<NormalizeImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'Normalize' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'Normalize' is not supported on specified platform");
@@ -113,17 +113,9 @@ Normalize::Normalize(const Value& args, int version) : Transform(args) {
   impl_ = impl_creator->Create(args);
 }
 
-class NormalizeCreator : public Creator<Transform> {
- public:
-  const char* GetName() const override { return "Normalize"; }
-  int GetVersion() const override { return version_; }
-  ReturnType Create(const Value& args) override { return make_unique<Normalize>(args, version_); }
-
- private:
-  int version_{1};
-};
-
-REGISTER_MODULE(Transform, NormalizeCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (Normalize, 0), [](const Value& config) {
+  return std::make_unique<Normalize>(config, 0);
+});
 
 MMDEPLOY_DEFINE_REGISTRY(NormalizeImpl);
 
diff --git a/csrc/mmdeploy/preprocess/transform/normalize.h b/csrc/mmdeploy/preprocess/transform/normalize.h
index adca2a9305..272a4c92bd 100644
--- a/csrc/mmdeploy/preprocess/transform/normalize.h
+++ b/csrc/mmdeploy/preprocess/transform/normalize.h
@@ -41,7 +41,7 @@ class MMDEPLOY_API Normalize : public Transform {
   std::unique_ptr<NormalizeImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(NormalizeImpl);
+MMDEPLOY_DECLARE_REGISTRY(NormalizeImpl, std::unique_ptr<NormalizeImpl>(const Value& config));
 
 }  // namespace mmdeploy
 #endif  // MMDEPLOY_NORMALIZE_H
diff --git a/csrc/mmdeploy/preprocess/transform/pad.cpp b/csrc/mmdeploy/preprocess/transform/pad.cpp
index d81d2b18c1..4439356760 100644
--- a/csrc/mmdeploy/preprocess/transform/pad.cpp
+++ b/csrc/mmdeploy/preprocess/transform/pad.cpp
@@ -126,7 +126,7 @@ Result<Value> PadImpl::Process(const Value& input) {
 }
 
 Pad::Pad(const Value& args, int version) : Transform(args) {
-  auto impl_creator = Registry<PadImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<PadImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'Pad' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'Pad' is not supported on specified platform");
@@ -134,17 +134,9 @@ Pad::Pad(const Value& args, int version) : Transform(args) {
   impl_ = impl_creator->Create(args);
 }
 
-class PadCreator : public Creator<Transform> {
- public:
-  const char* GetName() const override { return "Pad"; }
-  int GetVersion() const override { return version_; }
-  ReturnType Create(const Value& args) override { return make_unique<Pad>(args, version_); }
-
- private:
-  int version_{1};
-};
-
-REGISTER_MODULE(Transform, PadCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (Pad, 0), [](const Value& config) {
+  return std::make_unique<Pad>(config, 0);
+});
 
 MMDEPLOY_DEFINE_REGISTRY(PadImpl);
 
diff --git a/csrc/mmdeploy/preprocess/transform/pad.h b/csrc/mmdeploy/preprocess/transform/pad.h
index 12fb0fbf80..a05631548a 100644
--- a/csrc/mmdeploy/preprocess/transform/pad.h
+++ b/csrc/mmdeploy/preprocess/transform/pad.h
@@ -49,7 +49,7 @@ class MMDEPLOY_API Pad : public Transform {
   std::unique_ptr<PadImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(PadImpl);
+MMDEPLOY_DECLARE_REGISTRY(PadImpl, std::unique_ptr<PadImpl>(const Value& config));
 
 }  // namespace mmdeploy
 
diff --git a/csrc/mmdeploy/preprocess/transform/resize.cpp b/csrc/mmdeploy/preprocess/transform/resize.cpp
index 9f48cb0da9..1ea87f06a6 100644
--- a/csrc/mmdeploy/preprocess/transform/resize.cpp
+++ b/csrc/mmdeploy/preprocess/transform/resize.cpp
@@ -123,7 +123,7 @@ Result<Value> ResizeImpl::Process(const Value& input) {
 }
 
 Resize::Resize(const Value& args, int version) : Transform(args) {
-  auto impl_creator = Registry<ResizeImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<ResizeImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'Resize' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'Resize' is not supported on specified platform");
@@ -131,17 +131,9 @@ Resize::Resize(const Value& args, int version) : Transform(args) {
   impl_ = impl_creator->Create(args);
 }
 
-class ResizeCreator : public Creator<Transform> {
- public:
-  const char* GetName() const override { return "Resize"; }
-  int GetVersion() const override { return version_; }
-  ReturnType Create(const Value& args) override { return make_unique<Resize>(args, version_); }
-
- private:
-  int version_{1};
-};
-
-REGISTER_MODULE(Transform, ResizeCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (Resize, 0), [](const Value& config) {
+  return std::make_unique<Resize>(config, 0);
+});
 
 MMDEPLOY_DEFINE_REGISTRY(ResizeImpl);
 
diff --git a/csrc/mmdeploy/preprocess/transform/resize.h b/csrc/mmdeploy/preprocess/transform/resize.h
index bd562f0e20..f512e75242 100644
--- a/csrc/mmdeploy/preprocess/transform/resize.h
+++ b/csrc/mmdeploy/preprocess/transform/resize.h
@@ -43,7 +43,7 @@ class MMDEPLOY_API Resize : public Transform {
   static const std::string name_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(ResizeImpl);
+MMDEPLOY_DECLARE_REGISTRY(ResizeImpl, std::unique_ptr<ResizeImpl>(const Value& config));
 
 }  // namespace mmdeploy
 #endif  // MMDEPLOY_RESIZE_H
diff --git a/csrc/mmdeploy/preprocess/transform/ten_crop.cpp b/csrc/mmdeploy/preprocess/transform/ten_crop.cpp
index 7619b147e3..a1d7da576e 100644
--- a/csrc/mmdeploy/preprocess/transform/ten_crop.cpp
+++ b/csrc/mmdeploy/preprocess/transform/ten_crop.cpp
@@ -65,7 +65,7 @@ Result<Value> TenCropImpl::Process(const Value& input) {
 }
 
 TenCrop::TenCrop(const Value& args, int version) : Transform(args) {
-  auto impl_creator = Registry<TenCropImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<TenCropImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'TenCrop' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'Resize' is not supported on specified platform");
@@ -73,18 +73,9 @@ TenCrop::TenCrop(const Value& args, int version) : Transform(args) {
   impl_ = impl_creator->Create(args);
 }
 
-class TenCropCreator : public Creator<Transform> {
- public:
-  const char* GetName(void) const override { return "TenCrop"; }
-  int GetVersion(void) const override { return version_; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<TenCrop>(args, version_);
-  }
-
- private:
-  int version_{1};
-};
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (TenCrop, 0), [](const Value& config) {
+  return std::make_unique<TenCrop>(config, 0);
+});
 
-REGISTER_MODULE(Transform, TenCropCreator);
 MMDEPLOY_DEFINE_REGISTRY(TenCropImpl);
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/preprocess/transform/ten_crop.h b/csrc/mmdeploy/preprocess/transform/ten_crop.h
index 87ae4ac0f4..a9fc7dffd5 100644
--- a/csrc/mmdeploy/preprocess/transform/ten_crop.h
+++ b/csrc/mmdeploy/preprocess/transform/ten_crop.h
@@ -43,7 +43,8 @@ class MMDEPLOY_API TenCrop : public Transform {
   std::unique_ptr<TenCropImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(TenCropImpl);
+MMDEPLOY_DECLARE_REGISTRY(TenCropImpl, std::unique_ptr<TenCropImpl>(const Value& config));
+
 }  // namespace mmdeploy
 
 #endif
diff --git a/csrc/mmdeploy/preprocess/transform/three_crop.cpp b/csrc/mmdeploy/preprocess/transform/three_crop.cpp
index 6b6af65af8..3d7473c2f7 100644
--- a/csrc/mmdeploy/preprocess/transform/three_crop.cpp
+++ b/csrc/mmdeploy/preprocess/transform/three_crop.cpp
@@ -75,7 +75,7 @@ Result<Value> ThreeCropImpl::Process(const Value& input) {
 }
 
 ThreeCrop::ThreeCrop(const Value& args, int version) : Transform(args) {
-  auto impl_creator = Registry<ThreeCropImpl>::Get().GetCreator(specified_platform_, version);
+  auto impl_creator = gRegistry<ThreeCropImpl>().Get(specified_platform_, version);
   if (nullptr == impl_creator) {
     MMDEPLOY_ERROR("'ThreeCrop' is not supported on '{}' platform", specified_platform_);
     throw std::domain_error("'Resize' is not supported on specified platform");
@@ -83,19 +83,10 @@ ThreeCrop::ThreeCrop(const Value& args, int version) : Transform(args) {
   impl_ = impl_creator->Create(args);
 }
 
-class ThreeCropCreator : public Creator<Transform> {
- public:
-  const char* GetName(void) const override { return "ThreeCrop"; }
-  int GetVersion(void) const override { return version_; }
-  ReturnType Create(const Value& args) override {
-    return std::make_unique<ThreeCrop>(args, version_);
-  }
-
- private:
-  int version_{1};
-};
+MMDEPLOY_REGISTER_FACTORY_FUNC(Transform, (ThreeCrop, 0), [](const Value& config) {
+  return std::make_unique<ThreeCrop>(config, 0);
+});
 
-REGISTER_MODULE(Transform, ThreeCropCreator);
 MMDEPLOY_DEFINE_REGISTRY(ThreeCropImpl);
 
 }  // namespace mmdeploy
diff --git a/csrc/mmdeploy/preprocess/transform/three_crop.h b/csrc/mmdeploy/preprocess/transform/three_crop.h
index 74b24956e6..9e2f265c21 100644
--- a/csrc/mmdeploy/preprocess/transform/three_crop.h
+++ b/csrc/mmdeploy/preprocess/transform/three_crop.h
@@ -42,7 +42,8 @@ class MMDEPLOY_API ThreeCrop : public Transform {
   std::unique_ptr<ThreeCropImpl> impl_;
 };
 
-MMDEPLOY_DECLARE_REGISTRY(ThreeCropImpl);
+MMDEPLOY_DECLARE_REGISTRY(ThreeCropImpl, std::unique_ptr<ThreeCropImpl>(const Value& config));
+
 }  // namespace mmdeploy
 
 #endif
diff --git a/csrc/mmdeploy/preprocess/transform/transform.h b/csrc/mmdeploy/preprocess/transform/transform.h
index 353996b15f..5363049409 100644
--- a/csrc/mmdeploy/preprocess/transform/transform.h
+++ b/csrc/mmdeploy/preprocess/transform/transform.h
@@ -40,13 +40,13 @@ class MMDEPLOY_API Transform : public Module {
   template <typename T>
   [[deprecated]] std::unique_ptr<T> Instantiate(const char* transform_type, const Value& args,
                                                 int version = 0) {
-    std::unique_ptr<T> impl(nullptr);
-    auto impl_creator = Registry<T>::Get().GetCreator(specified_platform_, version);
+    std::unique_ptr<T> impl;
+    auto impl_creator = gRegistry<T>().Get(specified_platform_, version);
     if (nullptr == impl_creator) {
       MMDEPLOY_WARN("Cannot find {} implementation on platform {}", transform_type,
                     specified_platform_);
       for (auto& name : candidate_platforms_) {
-        impl_creator = Registry<T>::Get().GetCreator(name);
+        impl_creator = gRegistry<T>().Get(name);
         if (impl_creator) {
           MMDEPLOY_INFO("Fallback {} implementation to platform {}", transform_type, name);
           break;
@@ -73,8 +73,12 @@ void SetTransformData(Value& dst, Key&& key, Val val) {
   dst["__data__"].push_back(std::move(val));
 }
 
-MMDEPLOY_DECLARE_REGISTRY(Transform);
+MMDEPLOY_DECLARE_REGISTRY(Transform, std::unique_ptr<Transform>(const Value& config));
 
 }  // namespace mmdeploy
 
+#define MMDEPLOY_REGISTER_TRANSFORM_IMPL(base_type, desc, impl_type) \
+  MMDEPLOY_REGISTER_FACTORY_FUNC(                                    \
+      base_type, desc, [](const Value& config) { return std::make_unique<impl_type>(config); });
+
 #endif  // MMDEPLOY_TRANSFORM_H
diff --git a/csrc/mmdeploy/preprocess/transform_module.cpp b/csrc/mmdeploy/preprocess/transform_module.cpp
index 33f149a0d6..cf93ef8bcd 100644
--- a/csrc/mmdeploy/preprocess/transform_module.cpp
+++ b/csrc/mmdeploy/preprocess/transform_module.cpp
@@ -16,10 +16,10 @@ TransformModule::TransformModule(TransformModule&&) noexcept = default;
 
 TransformModule::TransformModule(const Value& args) {
   const auto type = "Compose";
-  auto creator = Registry<Transform>::Get().GetCreator(type, 1);
+  auto creator = gRegistry<Transform>().Get(type);
   if (!creator) {
     MMDEPLOY_ERROR("Unable to find Transform creator: {}. Available transforms: {}", type,
-                   Registry<Transform>::Get().List());
+                   gRegistry<Transform>().List());
     throw_exception(eEntryNotFound);
   }
   auto cfg = args;
@@ -49,15 +49,8 @@ Result<Value> TransformModule::operator()(const Value& input) {
   return ret;
 }
 
-class MMDEPLOY_API TransformModuleCreator : public Creator<Module> {
- public:
-  const char* GetName() const override { return "Transform"; }
-  int GetVersion() const override { return 0; }
-  std::unique_ptr<Module> Create(const Value& value) override {
-    return CreateTask(TransformModule{value});
-  }
-};
-
-REGISTER_MODULE(Module, TransformModuleCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Module, (Transform, 0), [](const Value& config) {
+  return CreateTask(TransformModule{config});
+});
 
 }  // namespace mmdeploy
diff --git a/demo/csrc/CMakeLists.txt b/demo/csrc/CMakeLists.txt
index e3197af6dd..85ffc6f32c 100644
--- a/demo/csrc/CMakeLists.txt
+++ b/demo/csrc/CMakeLists.txt
@@ -40,8 +40,8 @@ add_example(pose_detector c pose_detection)
 add_example(rotated_detector c rotated_object_detection)
 add_example(video_recognizer c video_recognition)
 # TODO: figure out a better way
-#add_example("" c det_cls)
-#add_example("" c det_pose)
+# add_example("" c det_cls)
+# add_example("" c det_pose)
 
 if (MMDEPLOY_BUILD_SDK_CXX_API)
     add_example(classifier cpp classifier)
diff --git a/demo/csrc/c/det_cls.cpp b/demo/csrc/c/det_cls.cpp
index e216b34f8e..882ecaa22e 100644
--- a/demo/csrc/c/det_cls.cpp
+++ b/demo/csrc/c/det_cls.cpp
@@ -70,13 +70,8 @@ class CropBox {
   }
 };
 
-class CropBoxCreator : public Creator<Module> {
- public:
-  const char* GetName() const override { return "CropBox"; }
-  std::unique_ptr<Module> Create(const Value& value) override { return CreateTask(CropBox{}); }
-};
-
-REGISTER_MODULE(Module, CropBoxCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Module, (CropBox, 0),
+                               [](const Value&) { return CreateTask(CropBox{}); });
 
 int main() {
   auto config = from_json<Value>(config_json);
diff --git a/demo/csrc/c/det_pose.cpp b/demo/csrc/c/det_pose.cpp
index c0079d691d..30f80f1a77 100644
--- a/demo/csrc/c/det_pose.cpp
+++ b/demo/csrc/c/det_pose.cpp
@@ -23,7 +23,7 @@ const auto config_json = R"(
       "type": "Inference",
       "input": "img",
       "output": "dets",
-      "params": { "model": "../_detection_tmp_model" }
+      "params": { "model": "TBD" }
     },
     {
       "type": "Task",
@@ -45,7 +45,7 @@ const auto config_json = R"(
           "type": "Inference",
           "input": "imgs_with_bboxes",
           "output": "keypoints",
-          "params": { "model": "../posedet_tmp_model" }
+          "params": { "model": "TBD" }
         }
       ],
       "output": "*keypoints"
@@ -70,41 +70,39 @@ class AddBboxField {
   }
 };
 
-class AddBboxFieldCreator : public Creator<Module> {
- public:
-  const char* GetName() const override { return "AddBboxField"; }
-  std::unique_ptr<Module> Create(const Value& value) override { return CreateTask(AddBboxField{}); }
-};
-
-REGISTER_MODULE(Module, AddBboxFieldCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Module, (AddBboxField, 0),
+                               [](const Value&) { return CreateTask(AddBboxField{}); });
 
-class FilterBbox {
- public:
-  Result<Value> operator()(const Value& dets) {
-    Value::Array rets;
-    for (const auto& det : dets) {
-      if (det["label_id"].get<int>() == 0 && det["score"].get<float>() >= 0.3) {
-        rets.push_back(det);
-      }
+Result<Value> FilterBbox(const Value& dets) {
+  Value::Array rets;
+  for (const auto& det : dets) {
+    if (det["label_id"].get<int>() == 0 && det["score"].get<float>() >= 0.3) {
+      rets.push_back(det);
     }
-    return rets;
   }
-};
-
-class FilterBboxCreator : public Creator<Module> {
- public:
-  const char* GetName() const override { return "FilterBbox"; }
-  std::unique_ptr<Module> Create(const Value& value) override { return CreateTask(FilterBbox{}); }
-};
+  return rets;
+}
 
-REGISTER_MODULE(Module, FilterBboxCreator);
+MMDEPLOY_REGISTER_FACTORY_FUNC(Module, (FilterBbox, 0),
+                               [](const Value&) { return CreateTask(FilterBbox); });
 
 static std::vector<std::pair<int, int>> skeleton{
     {15, 13}, {13, 11}, {16, 14}, {14, 12}, {11, 12}, {5, 11}, {6, 12}, {5, 6}, {5, 7}, {6, 8},
     {7, 9},   {8, 10},  {1, 2},   {0, 1},   {0, 2},   {1, 3},  {2, 4},  {3, 5}, {4, 6}};
 
-int main() {
+int main(int argc, char* argv[]) {
+  if (argc != 5) {
+    MMDEPLOY_INFO("usage: det_pose device det_model pose_model image");
+    return 0;
+  }
+  const auto device_name = argv[1];
+  const auto det_model_path = argv[2];
+  const auto pose_model_path = argv[3];
+  const auto image_path = argv[4];
+
   auto config = from_json<Value>(config_json);
+  config["tasks"][0]["params"]["model"] = det_model_path;
+  config["tasks"][2]["tasks"][1]["params"]["model"] = pose_model_path;
 
   mmdeploy_context_t context{};
   mmdeploy_context_create(&context);
@@ -115,17 +113,24 @@ int main() {
   mmdeploy_context_add(context, MMDEPLOY_TYPE_SCHEDULER, "net", single_thread);
   mmdeploy_context_add(context, MMDEPLOY_TYPE_SCHEDULER, "postprocess", thread_pool);
 
+  mmdeploy_device_t device{};
+  mmdeploy_device_create(device_name, 0, &device);
+  mmdeploy_context_add(context, MMDEPLOY_TYPE_DEVICE, nullptr, device);
+
   mmdeploy_pipeline_t pipeline{};
   if (auto ec = mmdeploy_pipeline_create_v3((mmdeploy_value_t)&config, context, &pipeline)) {
     MMDEPLOY_ERROR("failed to create pipeline: {}", ec);
     return -1;
   }
 
-  cv::Mat mat = cv::imread("../ezgif-5-6ec14aca55.jpg");
+  cv::Mat mat = cv::imread(image_path);
+  if (!mat.data) {
+    MMDEPLOY_ERROR("invalid image path: {}", image_path);
+  }
   framework::Mat img(mat.rows, mat.cols, PixelFormat::kBGR, DataType::kINT8, mat.data,
                      framework::Device(0));
 
-  Value input = Value::Array{Value::Array{Value::Object{{"ori_img", img}}}};
+  Value input{{{{"ori_img", img}}}};
 
   mmdeploy_value_t tmp{};
   mmdeploy_pipeline_apply(pipeline, (mmdeploy_value_t)&input, &tmp);
@@ -135,16 +140,16 @@ int main() {
   mmdeploy_detector_get_result(tmp, &dets, &det_count);
 
   auto output = std::move(*(Value*)tmp);
+  mmdeploy_value_destroy(tmp);
+
+  // result of second output
+  auto& pose = output[1];
 
   mmdeploy_pose_detection_t* kps{};
-  Value pose;
-  pose.push_back(output[1]);
   mmdeploy_pose_detector_get_result((mmdeploy_value_t)&pose, &kps);
 
   MMDEPLOY_INFO("{}", *det_count);
 
-  mmdeploy_value_destroy(tmp);
-
   for (int i = 0; i < *det_count; ++i) {
     if (dets[i].label_id != 0 || dets[i].score < 0.3) {
       continue;
@@ -166,6 +171,8 @@ int main() {
     }
   }
 
+  mmdeploy_pose_detector_release_result(kps, pose.size());
+
   cv::imwrite("output_det_pose.jpg", mat);
 
   mmdeploy_pipeline_destroy(pipeline);
diff --git a/demo/csrc/cpp/pose_tracker.cpp b/demo/csrc/cpp/pose_tracker.cpp
index c3193351e0..beebb155eb 100644
--- a/demo/csrc/cpp/pose_tracker.cpp
+++ b/demo/csrc/cpp/pose_tracker.cpp
@@ -54,12 +54,8 @@ const auto config_json = R"(
 
 namespace mmdeploy {
 
-#define REGISTER_SIMPLE_MODULE(name, fn)                                             \
-  class name##_Creator : public ::mmdeploy::Creator<Module> {                        \
-    const char* GetName() const override { return #name; }                           \
-    std::unique_ptr<Module> Create(const Value&) override { return CreateTask(fn); } \
-  };                                                                                 \
-  REGISTER_MODULE(Module, name##_Creator)
+#define REGISTER_SIMPLE_MODULE(name, fn) \
+  MMDEPLOY_REGISTER_FACTORY_FUNC(Module, (name, 0), [](const Value&) { return CreateTask(fn); });
 
 std::optional<std::array<float, 4>> keypoints_to_bbox(const std::vector<cv::Point2f>& keypoints,
                                                       const std::vector<float>& scores, float img_h,
diff --git a/tests/test_csrc/core/test_execution.cpp b/tests/test_csrc/core/test_execution.cpp
index 5704883cb2..debbd30f01 100644
--- a/tests/test_csrc/core/test_execution.cpp
+++ b/tests/test_csrc/core/test_execution.cpp
@@ -145,7 +145,7 @@ TEST_CASE("test simple type erase", "[execution]") { G(); }
 
 void TestFunc(const char* sched_name) {
   //  MMDEPLOY_INFO("testing with scheduler: {}", sched_name);
-  auto creator = Registry<TypeErasedScheduler<Value>>::Get().GetCreator(sched_name);
+  auto creator = gRegistry<TypeErasedScheduler<Value>>().Get(sched_name);
   REQUIRE(creator);
   auto sched = creator->Create({});
   SECTION("Schedule") { (void)SyncWait(Schedule(sched)); }
diff --git a/tests/test_csrc/core/test_registry.cpp b/tests/test_csrc/core/test_registry.cpp
index 9d1cc49821..64c0feffa8 100644
--- a/tests/test_csrc/core/test_registry.cpp
+++ b/tests/test_csrc/core/test_registry.cpp
@@ -27,15 +27,15 @@ class ImageDecoder final : public Decoder {
 
 class ImageDecoderCreator : public DecoderCreator {
  public:
-  const char* GetName() const override { return "image"; }
-  int GetVersion() const override { return 2004000; }
+  std::string_view name() const noexcept override { return "image"; }
+  int version() const noexcept override { return 2004000; }
   std::unique_ptr<Decoder> Create(const Value& value) override {
     ImageDecoder decoder;
     return std::make_unique<ImageDecoder>(std::move(decoder));
   }
 };
 
-REGISTER_MODULE(Decoder, ImageDecoderCreator);
+MMDEPLOY_REGISTER_CREATOR(Decoder, ImageDecoderCreator);
 
 namespace no_mmdeploy {
 class ImageDecoder final : public Decoder {
@@ -54,38 +54,39 @@ class ImageDecoder final : public Decoder {
 
 class ImageDecoderCreator : public DecoderCreator {
  public:
-  const char* GetName() const override { return "image"; }
-  int GetVersion() const override { return 1003006; };
+  std::string_view name() const noexcept override { return "image"; }
+  int version() const noexcept override { return 1003006; };
   std::unique_ptr<Decoder> Create(const Value& value) override {
     ImageDecoder decoder;
     return std::make_unique<ImageDecoder>(std::move(decoder));
   }
 };
-REGISTER_MODULE(Decoder, ImageDecoderCreator);
+
+MMDEPLOY_REGISTER_CREATOR(Decoder, ImageDecoderCreator);
+
 }  // namespace no_mmdeploy
 
 TEST_CASE("define module in global namespace", "[registry]") {
-  auto registry = Registry<Decoder>::Get();
+  auto& registry = gRegistry<Decoder>();
   std::string module_type{"image"};
   SECTION("get not existing decoder") {
-    auto creator = registry.GetCreator("dummy");
+    auto creator = registry.Get("dummy");
     CHECK(creator == nullptr);
   }
   SECTION("get creator without specifying version") {
-    auto creator = registry.GetCreator(module_type);
-    CHECK(creator != nullptr);
-    CHECK(creator->GetVersion() != 0);
+    auto creator = registry.Get(module_type);
+    CHECK(creator == nullptr);
   }
   SECTION("get creator by providing version") {
-    auto creator = registry.GetCreator(module_type, 100);
+    auto creator = registry.Get(module_type, 100);
     CHECK(creator == nullptr);
 
-    creator = registry.GetCreator(module_type, 2004000);
+    creator = registry.Get(module_type, 2004000);
     CHECK(creator != nullptr);
     auto decoder = creator->Create({});
     CHECK(decoder->Process({{"image_path", "./test.jpg"}}));
 
-    auto another_creator = registry.GetCreator(module_type, 1003006);
+    auto another_creator = registry.Get(module_type, 1003006);
     CHECK(another_creator != nullptr);
     auto another_decoder = another_creator->Create({});
     CHECK(!another_decoder->Process({{"image_path", "./test.jpg"}}));
diff --git a/tests/test_csrc/graph/test_cond.cpp b/tests/test_csrc/graph/test_cond.cpp
index f542bc2041..89db07d789 100644
--- a/tests/test_csrc/graph/test_cond.cpp
+++ b/tests/test_csrc/graph/test_cond.cpp
@@ -12,12 +12,13 @@ namespace {
 
 class PlusCreator : public Creator<Module> {
  public:
-  const char* GetName() const override { return "Plus"; }
+  std::string_view name() const noexcept override { return "Plus"; }
   std::unique_ptr<Module> Create(const Value&) override {
     return CreateTask([](int a, int b) { return a + b; });
   }
 };
-REGISTER_MODULE(Module, PlusCreator);
+
+MMDEPLOY_REGISTER_CREATOR(Module, PlusCreator);
 
 const auto json_config1 = R"(
 {
diff --git a/tests/test_csrc/model/test_directory_model.cpp b/tests/test_csrc/model/test_directory_model.cpp
index 8cc960a15f..e701d66a64 100644
--- a/tests/test_csrc/model/test_directory_model.cpp
+++ b/tests/test_csrc/model/test_directory_model.cpp
@@ -12,9 +12,9 @@ using namespace framework;
 
 TEST_CASE("test directory model", "[.model][resource]") {
   std::unique_ptr<ModelImpl> model_impl;
-  for (auto& entry : ModelRegistry::Get().ListEntries()) {
-    if (entry.name == "DirectoryModel") {
-      model_impl = entry.creator();
+  for (auto& entry : gRegistry<ModelImpl>().Creators()) {
+    if (entry->name() == "DirectoryModel") {
+      model_impl = entry->Create();
       break;
     }
   }
diff --git a/tests/test_csrc/model/test_model.cpp b/tests/test_csrc/model/test_model.cpp
index 1335f2ec3f..93dd797449 100644
--- a/tests/test_csrc/model/test_model.cpp
+++ b/tests/test_csrc/model/test_model.cpp
@@ -47,21 +47,3 @@ TEST_CASE("model init", "[model]") {
     }
   }
 }
-
-TEST_CASE("ModelRegistry", "[model]") {
-  class ANewModelImpl : public ModelImpl {
-    Result<void> Init(const std::string& sdk_model_path) override { return Status(eNotSupported); }
-    Result<std::string> ReadFile(const std::string& file_path) const override {
-      return Status(eNotSupported);
-    }
-    Result<deploy_meta_info_t> ReadMeta() const override {
-      deploy_meta_info_t meta;
-      return meta;
-    }
-  };
-
-  // Test duplicated register. `DirectoryModel` is already registered.
-  (void)ModelRegistry::Get().Register("DirectoryModel", []() -> std::unique_ptr<ModelImpl> {
-    return std::make_unique<ANewModelImpl>();
-  });
-}
diff --git a/tests/test_csrc/net/test_ncnn_net.cpp b/tests/test_csrc/net/test_ncnn_net.cpp
index 4a0b11754c..0546014592 100644
--- a/tests/test_csrc/net/test_ncnn_net.cpp
+++ b/tests/test_csrc/net/test_ncnn_net.cpp
@@ -20,7 +20,7 @@ TEST_CASE("test ncnn net", "[.ncnn_net][resource]") {
   REQUIRE(model);
 
   auto backend("ncnn");
-  auto creator = Registry<Net>::Get().GetCreator(backend);
+  auto creator = gRegistry<Net>().Get(backend);
   REQUIRE(creator);
 
   Device device{"cpu"};
diff --git a/tests/test_csrc/net/test_openvino_net.cpp b/tests/test_csrc/net/test_openvino_net.cpp
index ba9fd57b4c..f708771adb 100644
--- a/tests/test_csrc/net/test_openvino_net.cpp
+++ b/tests/test_csrc/net/test_openvino_net.cpp
@@ -20,7 +20,7 @@ TEST_CASE("test openvino net", "[.openvino_net][resource]") {
   REQUIRE(model);
 
   auto backend("openvino");
-  auto creator = Registry<Net>::Get().GetCreator(backend);
+  auto creator = gRegistry<Net>().Get(backend);
   REQUIRE(creator);
 
   Device device{"cpu"};
diff --git a/tests/test_csrc/net/test_ort_net.cpp b/tests/test_csrc/net/test_ort_net.cpp
index 9e11213b5e..13f4d23064 100644
--- a/tests/test_csrc/net/test_ort_net.cpp
+++ b/tests/test_csrc/net/test_ort_net.cpp
@@ -20,7 +20,7 @@ TEST_CASE("test ort net", "[.ort_net][resource]") {
   REQUIRE(model);
 
   auto backend("onnxruntime");
-  auto creator = Registry<Net>::Get().GetCreator(backend);
+  auto creator = gRegistry<Net>().Get(backend);
   REQUIRE(creator);
 
   Device device{"cpu"};
diff --git a/tests/test_csrc/net/test_ppl_net.cpp b/tests/test_csrc/net/test_ppl_net.cpp
index a2fef57802..55e70b3627 100644
--- a/tests/test_csrc/net/test_ppl_net.cpp
+++ b/tests/test_csrc/net/test_ppl_net.cpp
@@ -20,7 +20,7 @@ TEST_CASE("test pplnn net", "[.ppl_net][resource]") {
   REQUIRE(model);
 
   auto backend = "pplnn";
-  auto creator = Registry<Net>::Get().GetCreator(backend);
+  auto creator = gRegistry<Net>().Get(backend);
   REQUIRE(creator);
 
   Device device{"cpu"};
diff --git a/tests/test_csrc/net/test_trt_net.cpp b/tests/test_csrc/net/test_trt_net.cpp
index 6b982e9335..c0da700789 100644
--- a/tests/test_csrc/net/test_trt_net.cpp
+++ b/tests/test_csrc/net/test_trt_net.cpp
@@ -20,7 +20,7 @@ TEST_CASE("test trt net", "[.trt_net][resource]") {
   REQUIRE(model);
 
   auto backend("tensorrt");
-  auto creator = Registry<Net>::Get().GetCreator(backend);
+  auto creator = gRegistry<Net>().Get(backend);
   REQUIRE(creator);
 
   Device device{"cuda"};
diff --git a/tests/test_csrc/preprocess/test_collect.cpp b/tests/test_csrc/preprocess/test_collect.cpp
index dd8003a785..47f40b4bf4 100644
--- a/tests/test_csrc/preprocess/test_collect.cpp
+++ b/tests/test_csrc/preprocess/test_collect.cpp
@@ -13,7 +13,7 @@ TEST_CASE("test collect constructor", "[collect]") {
   Value cfg = {{"context", {{"device", device}, {"stream", stream}}}};
 
   std::string transform_type{"Collect"};
-  auto creator = Registry<Transform>::Get().GetCreator(transform_type, 1);
+  auto creator = gRegistry<Transform>().Get(transform_type);
   REQUIRE(creator != nullptr);
 
   REQUIRE_THROWS(creator->Create(cfg));
@@ -63,7 +63,7 @@ TEST_CASE("test collect", "[collect]") {
     args["meta_keys"].push_back(meta_key);
   }
 
-  auto creator = Registry<Transform>::Get().GetCreator(transform_type, 1);
+  auto creator = gRegistry<Transform>().Get(transform_type);
   REQUIRE(creator != nullptr);
   auto module = creator->Create(args);
   REQUIRE(module != nullptr);
diff --git a/tests/test_csrc/preprocess/test_utils.cpp b/tests/test_csrc/preprocess/test_utils.cpp
index 561642eba8..262da74385 100644
--- a/tests/test_csrc/preprocess/test_utils.cpp
+++ b/tests/test_csrc/preprocess/test_utils.cpp
@@ -6,10 +6,10 @@ using namespace std;
 namespace mmdeploy::test {
 unique_ptr<Transform> CreateTransform(const Value& cfg, Device device, Stream stream) {
   auto op_type = cfg.value<string>("type", "");
-  auto op_version = cfg.value<int>("version", 1);
+  auto op_version = cfg.value<int>("version", -1);
 
   try {
-    auto creator = Registry<Transform>::Get().GetCreator(op_type, op_version);
+    auto creator = gRegistry<Transform>().Get(op_type, op_version);
     if (creator == nullptr) {
       return nullptr;
     }