diff --git a/android/sdk/src/main/jni/include/bridge/entry.h b/android/sdk/src/main/jni/include/bridge/entry.h
index a0110c02f..5553090d6 100644
--- a/android/sdk/src/main/jni/include/bridge/entry.h
+++ b/android/sdk/src/main/jni/include/bridge/entry.h
@@ -36,7 +36,8 @@ jlong InitInstance(JNIEnv* j_env,
                    jboolean j_bridge_param_json,
                    jboolean j_is_dev_module,
                    jobject j_callback,
-                   jlong j_group_id);
+                   jlong j_group_id,
+                   jobject j_vm_init_param);
 
 void DestroyInstance(JNIEnv* j_env,
                      jobject j_object,
diff --git a/android/sdk/src/main/jni/src/bridge/entry.cc b/android/sdk/src/main/jni/src/bridge/entry.cc
index a7a5242ee..9fea0c1b3 100644
--- a/android/sdk/src/main/jni/src/bridge/entry.cc
+++ b/android/sdk/src/main/jni/src/bridge/entry.cc
@@ -55,7 +55,8 @@ REGISTER_STATIC_JNI("com/tencent/mtt/hippy/HippyEngine",
 
 REGISTER_JNI("com/tencent/mtt/hippy/bridge/HippyBridgeImpl",
              "initJSFramework",
-             "([BZZZLcom/tencent/mtt/hippy/bridge/NativeCallback;J)J",
+             "([BZZZLcom/tencent/mtt/hippy/bridge/NativeCallback;"
+             "JLcom/tencent/mtt/hippy/HippyEngine$V8InitParams;)J",
              InitInstance)
 
 REGISTER_JNI("com/tencent/mtt/hippy/bridge/HippyBridgeImpl",
@@ -77,6 +78,7 @@ using Ctx = hippy::napi::Ctx;
 using StringViewUtils = hippy::base::StringViewUtils;
 using HippyFile = hippy::base::HippyFile;
 using V8VM = hippy::napi::V8VM;
+using V8VMInitParam = hippy::napi::V8VMInitParam;
 #ifdef ENABLE_INSPECTOR
 using V8InspectorClientImpl = hippy::inspector::V8InspectorClientImpl;
 std::shared_ptr<V8InspectorClientImpl> global_inspector = nullptr;
@@ -364,7 +366,8 @@ jlong InitInstance(JNIEnv* j_env,
                    jboolean j_enable_v8_serialization,
                    jboolean j_is_dev_module,
                    jobject j_callback,
-                   jlong j_group_id) {
+                   jlong j_group_id,
+                   jobject j_vm_init_param) {
   TDF_BASE_LOG(INFO) << "InitInstance begin, j_single_thread_mode = "
                      << static_cast<uint32_t>(j_single_thread_mode)
                      << ", j_bridge_param_json = "
@@ -444,6 +447,20 @@ jlong InitInstance(JNIEnv* j_env,
       std::make_pair(hippy::base::KScopeInitializedCBKey, scope_cb));
 
   int64_t group = j_group_id;
+  std::shared_ptr<V8VMInitParam> param;
+  if (j_vm_init_param) {
+    param = std::make_shared<V8VMInitParam>();
+    jclass cls = j_env->GetObjectClass(j_vm_init_param);
+    jfieldID init_field = j_env->GetFieldID(cls,"initialHeapSize","J");
+    jlong initial_heap_size_in_bytes = j_env->GetLongField(j_vm_init_param, init_field);
+    TDF_BASE_CHECK(initial_heap_size_in_bytes <= std::numeric_limits<size_t>::max());
+    param->initial_heap_size_in_bytes = static_cast<size_t>(initial_heap_size_in_bytes);
+    jfieldID max_field = j_env->GetFieldID(cls,"maximumHeapSize","J");
+    jlong maximum_heap_size_in_bytes = j_env->GetLongField(j_vm_init_param, max_field);
+    TDF_BASE_CHECK(maximum_heap_size_in_bytes <= std::numeric_limits<size_t>::max());
+    param->maximum_heap_size_in_bytes = static_cast<size_t>(maximum_heap_size_in_bytes);
+    TDF_BASE_CHECK(initial_heap_size_in_bytes <= maximum_heap_size_in_bytes);
+  }
   std::shared_ptr<Engine> engine;
   if (j_is_dev_module) {
     std::lock_guard<std::mutex> lock(engine_mutex);
@@ -458,7 +475,7 @@ jlong InitInstance(JNIEnv* j_env,
       v8::Isolate* isolate = v8_vm->isolate_;
       isolate->SetData(kRuntimeSlotIndex, reinterpret_cast<void*>(runtime_id));
     } else {
-      engine = std::make_shared<Engine>(std::move(engine_cb_map));
+      engine = std::make_shared<Engine>(std::move(engine_cb_map), param);
       runtime->SetEngine(engine);
       reuse_engine_map[group] = std::make_pair(engine, 1);
     }
@@ -478,13 +495,13 @@ jlong InitInstance(JNIEnv* j_env,
                           << ", use_count = " << engine.use_count();
     } else {
       TDF_BASE_DLOG(INFO) << "engine create";
-      engine = std::make_shared<Engine>(std::move(engine_cb_map));
+      engine = std::make_shared<Engine>(std::move(engine_cb_map), param);
       runtime->SetEngine(engine);
       reuse_engine_map[group] = std::make_pair(engine, 1);
     }
   } else {  // kDefaultEngineId
     TDF_BASE_DLOG(INFO) << "default create engine";
-    engine = std::make_shared<Engine>(std::move(engine_cb_map));
+    engine = std::make_shared<Engine>(std::move(engine_cb_map), param);
     runtime->SetEngine(engine);
   }
   runtime->SetScope(
diff --git a/core/include/core/engine.h b/core/include/core/engine.h
index ca231ee3e..4da8c82dd 100644
--- a/core/include/core/engine.h
+++ b/core/include/core/engine.h
@@ -38,10 +38,12 @@ class Engine {
  public:
   using RegisterMap = hippy::base::RegisterMap;
   using VM = hippy::napi::VM;
+  using VMInitParam = hippy::napi::VMInitParam;
   using RegisterFunction = hippy::base::RegisterFunction;
 
-  explicit Engine(
-      std::unique_ptr<RegisterMap> map = std::make_unique<RegisterMap>());
+  Engine(
+      std::unique_ptr<RegisterMap> map = std::make_unique<RegisterMap>(),
+      std::shared_ptr<VMInitParam> param = nullptr);
   virtual ~Engine();
 
   void Enter();
@@ -61,7 +63,7 @@ class Engine {
 
  private:
   void SetupThreads();
-  void CreateVM();
+  void CreateVM(std::shared_ptr<VMInitParam> param);
 
  private:
   static const uint32_t kDefaultWorkerPoolSize;
diff --git a/core/include/core/napi/js_native_api.h b/core/include/core/napi/js_native_api.h
index 9bfc94551..957f5243e 100644
--- a/core/include/core/napi/js_native_api.h
+++ b/core/include/core/napi/js_native_api.h
@@ -34,7 +34,7 @@ namespace napi {
 
 std::shared_ptr<CtxValue> GetInternalBindingFn(std::shared_ptr<Scope> scope);
 
-std::shared_ptr<VM> CreateVM();
+std::shared_ptr<VM> CreateVM(std::shared_ptr<VMInitParam> param);
 
 std::shared_ptr<TryCatch> CreateTryCatchScope(bool enable,
                                               std::shared_ptr<Ctx> ctx);
diff --git a/core/include/core/napi/js_native_api_types.h b/core/include/core/napi/js_native_api_types.h
index 900f8403b..1e7747a99 100644
--- a/core/include/core/napi/js_native_api_types.h
+++ b/core/include/core/napi/js_native_api_types.h
@@ -172,9 +172,11 @@ class Ctx {
       std::shared_ptr<JSValueWrapper> wrapper) = 0;
 };
 
+struct VMInitParam {};
+
 class VM {
  public:
-  VM(){};
+  VM(std::shared_ptr<VMInitParam> param = nullptr){};
   virtual ~VM() { TDF_BASE_DLOG(INFO) << "~VM"; };
 
   virtual std::shared_ptr<Ctx> CreateContext() = 0;
diff --git a/core/include/core/napi/v8/js_native_api_v8.h b/core/include/core/napi/v8/js_native_api_v8.h
index 45266dea3..ec5ea8d31 100644
--- a/core/include/core/napi/v8/js_native_api_v8.h
+++ b/core/include/core/napi/v8/js_native_api_v8.h
@@ -50,9 +50,14 @@ void JsCallbackFunc(const v8::FunctionCallbackInfo<v8::Value>& info);
 void NativeCallbackFunc(const v8::FunctionCallbackInfo<v8::Value>& info);
 void GetInternalBinding(const v8::FunctionCallbackInfo<v8::Value>& info);
 
+struct V8VMInitParam: public VMInitParam {
+  size_t initial_heap_size_in_bytes;
+  size_t maximum_heap_size_in_bytes;
+};
+
 class V8VM : public VM {
  public:
-  V8VM();
+  V8VM(std::shared_ptr<V8VMInitParam> param);
   ~V8VM();
 
   virtual std::shared_ptr<Ctx> CreateContext();
diff --git a/core/src/engine.cc b/core/src/engine.cc
index 2c105f4a1..590d6b0a2 100644
--- a/core/src/engine.cc
+++ b/core/src/engine.cc
@@ -31,12 +31,12 @@
 
 const uint32_t Engine::kDefaultWorkerPoolSize = 1;
 
-Engine::Engine(std::unique_ptr<RegisterMap> map)
+Engine::Engine(std::unique_ptr<RegisterMap> map, std::shared_ptr<VMInitParam> init_param)
     : vm_(nullptr), map_(std::move(map)), scope_cnt_(0) {
   SetupThreads();
 
   std::shared_ptr<JavaScriptTask> task = std::make_shared<JavaScriptTask>();
-  task->callback = [=] { CreateVM(); };
+  task->callback = [=] { CreateVM(init_param); };
   js_runner_->PostTask(task);
 }
 
@@ -91,9 +91,9 @@ void Engine::SetupThreads() {
   }
 }
 
-void Engine::CreateVM() {
+void Engine::CreateVM(std::shared_ptr<VMInitParam> param) {
   TDF_BASE_DLOG(INFO) << "Engine CreateVM";
-  vm_ = hippy::napi::CreateVM();
+  vm_ = hippy::napi::CreateVM(param);
 
   RegisterMap::const_iterator it = map_->find(hippy::base::kVMCreateCBKey);
   if (it != map_->end()) {
diff --git a/core/src/napi/jsc/js_native_api_jsc.cc b/core/src/napi/jsc/js_native_api_jsc.cc
index ddf09e243..1337f6600 100644
--- a/core/src/napi/jsc/js_native_api_jsc.cc
+++ b/core/src/napi/jsc/js_native_api_jsc.cc
@@ -122,7 +122,7 @@ JSObjectRef RegisterModule(std::shared_ptr<Scope> scope,
   return module_obj;
 }
 
-std::shared_ptr<VM> CreateVM() {
+std::shared_ptr<VM> CreateVM(std::shared_ptr<VMInitParam> param) {
   return std::make_shared<JSCVM>();
 }
 
diff --git a/core/src/napi/v8/js_native_api_v8.cc b/core/src/napi/v8/js_native_api_v8.cc
index 80901b2c8..128cd53ef 100644
--- a/core/src/napi/v8/js_native_api_v8.cc
+++ b/core/src/napi/v8/js_native_api_v8.cc
@@ -224,8 +224,8 @@ void GetInternalBinding(const v8::FunctionCallbackInfo<v8::Value>& info) {
   TDF_BASE_DLOG(INFO) << "v8 GetInternalBinding end";
 }
 
-std::shared_ptr<VM> CreateVM() {
-  return std::make_shared<V8VM>();
+std::shared_ptr<VM> CreateVM(std::shared_ptr<VMInitParam> param) {
+  return std::make_shared<V8VM>(std::static_pointer_cast<V8VMInitParam>(param));
 }
 
 std::shared_ptr<TryCatch> CreateTryCatchScope(bool enable,
@@ -237,7 +237,7 @@ void DetachThread() {
   JNIEnvironment::GetInstance()->DetachCurrentThread();
 }
 
-V8VM::V8VM() {
+V8VM::V8VM(std::shared_ptr<V8VMInitParam> param): VM(param) {
   TDF_BASE_DLOG(INFO) << "V8VM begin";
   {
     std::lock_guard<std::mutex> lock(mutex_);
@@ -249,6 +249,7 @@ V8VM::V8VM() {
     } else {
       TDF_BASE_DLOG(INFO) << "NewDefaultPlatform";
       platform_ = v8::platform::NewDefaultPlatform();
+
       v8::V8::SetFlagsFromString("--wasm-disable-structured-cloning",
                                  strlen("--wasm-disable-structured-cloning"));
 #if defined(V8_X5_LITE)
@@ -263,6 +264,10 @@ V8VM::V8VM() {
 
   create_params_.array_buffer_allocator =
       v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+  if (param) {
+    create_params_.constraints.ConfigureDefaultsFromHeapSize(param->initial_heap_size_in_bytes,
+                                                             param->maximum_heap_size_in_bytes);
+  }
   isolate_ = v8::Isolate::New(create_params_);
   isolate_->Enter();
   isolate_->SetCaptureStackTraceForUncaughtExceptions(true);