diff --git a/host/commands/assemble_cvd/Android.bp b/host/commands/assemble_cvd/Android.bp
index e296526..b03d8bf 100644
--- a/host/commands/assemble_cvd/Android.bp
+++ b/host/commands/assemble_cvd/Android.bp
@@ -39,6 +39,7 @@
         "super_image_mixer.cc",
     ],
     header_libs: [
+        "bootimg_headers",
         "cuttlefish_glog",
     ],
     shared_libs: [
diff --git a/host/commands/assemble_cvd/boot_image_unpacker.cc b/host/commands/assemble_cvd/boot_image_unpacker.cc
index 460cc1e..f1ead30 100644
--- a/host/commands/assemble_cvd/boot_image_unpacker.cc
+++ b/host/commands/assemble_cvd/boot_image_unpacker.cc
@@ -21,10 +21,10 @@
 
 #include <sstream>
 
+#include <bootimg.h>
 #include <glog/logging.h>
 
 #include "common/libs/utils/subprocess.h"
-#include "host/commands/assemble_cvd/bootimg.h"
 
 namespace cvd {
 
@@ -48,39 +48,58 @@
 }
 }  // namespace
 
-std::unique_ptr<BootImageUnpacker> BootImageUnpacker::FromImage(
-    const std::string& path) {
-  auto boot_img = SharedFD::Open(path.c_str(), O_RDONLY);
+std::unique_ptr<BootImageUnpacker> BootImageUnpacker::FromImages(
+    const std::string& boot_image_path,
+    const std::string& vendor_boot_image_path) {
+  auto boot_img = SharedFD::Open(boot_image_path.c_str(), O_RDONLY);
   if (!boot_img->IsOpen()) {
-    LOG(ERROR) << "Unable to open boot image (" << path
+    LOG(ERROR) << "Unable to open boot image (" << boot_image_path
                << "): " << boot_img->StrError();
     return nullptr;
   }
-  boot_img_hdr header;
+  boot_img_hdr_v3 header;
   auto bytes_read = boot_img->Read(&header, sizeof(header));
   if (bytes_read != sizeof(header)) {
     LOG(ERROR) << "Error reading boot image header";
     return nullptr;
   }
 
-  std::ostringstream cmdline;
-  cmdline << reinterpret_cast<char*>(&header.cmdline[0]);
-  if (header.extra_cmdline[0] != '\0') {
-    cmdline << " ";
-    cmdline << reinterpret_cast<char*>(&header.extra_cmdline[0]);
+  auto vendor_boot_img = SharedFD::Open(vendor_boot_image_path.c_str(),
+                                        O_RDONLY);
+  if (!vendor_boot_img->IsOpen()) {
+    LOG(ERROR) << "Unable to open vendor boot image (" << vendor_boot_image_path
+               << "): " << vendor_boot_img->StrError();
+    return nullptr;
+  }
+  vendor_boot_img_hdr_v3 vboot_header;
+  bytes_read = vendor_boot_img->Read(&vboot_header, sizeof(vboot_header));
+  if (bytes_read != sizeof(vboot_header)) {
+    LOG(ERROR) << "Error reading vendor boot image header";
+    return nullptr;
   }
 
-  uint32_t page_size = header.page_size;
-  // See system/core/mkbootimg/include/mkbootimg/bootimg.h for the origin of
+  std::ostringstream cmdline;
+  cmdline << reinterpret_cast<char*>(&header.cmdline[0]);
+  if (vboot_header.cmdline[0] != '\0') {
+    cmdline << " ";
+    cmdline << reinterpret_cast<char*>(&vboot_header.cmdline[0]);
+  }
+
+  uint32_t page_size = 4096;
+  // See system/tools/mkbootimg/include/bootimg/bootimg.h for the origin of
   // these offset calculations
   uint32_t kernel_offset = page_size;
   uint32_t ramdisk_offset =
       kernel_offset +
       ((header.kernel_size + page_size - 1) / page_size) * page_size;
+  uint32_t vendor_ramdisk_offset =
+      ((vboot_header.header_size + vboot_header.page_size - 1) / vboot_header.page_size) *
+      vboot_header.page_size;
 
   std::unique_ptr<BootImageUnpacker> ret(new BootImageUnpacker(
       boot_img, cmdline.str(), header.kernel_size, kernel_offset,
-      header.ramdisk_size, ramdisk_offset));
+      header.ramdisk_size, ramdisk_offset, vendor_boot_img,
+      vboot_header.vendor_ramdisk_size, vendor_ramdisk_offset));
 
   return ret;
 }
@@ -99,8 +118,14 @@
   return ExtractFile(boot_image_, ramdisk_image_offset_, ramdisk_image_size_,
                      path);
 }
+bool BootImageUnpacker::ExtractVendorRamdiskImage(const std::string& path) const {
+  if (vendor_ramdisk_image_size_ == 0) return false;
+  return ExtractFile(vendor_boot_image_, vendor_ramdisk_image_offset_,
+                     vendor_ramdisk_image_size_, path);
+}
 
 bool BootImageUnpacker::Unpack(const std::string& ramdisk_image_path,
+                               const std::string& vendor_ramdisk_image_path,
                                const std::string& kernel_image_path) {
   if (HasRamdiskImage()) {
     if (!ExtractRamdiskImage(ramdisk_image_path)) {
@@ -108,6 +133,12 @@
       return false;
     }
   }
+  if (HasVendorRamdiskImage()) {
+    if (!ExtractVendorRamdiskImage(vendor_ramdisk_image_path)) {
+      LOG(ERROR) << "Error extracting vendor ramdisk from venodr boot image";
+      return false;
+    }
+  }
   if (!kernel_image_path.empty()) {
     if (HasKernelImage()) {
       if (!ExtractKernelImage(kernel_image_path)) {
diff --git a/host/commands/assemble_cvd/boot_image_unpacker.h b/host/commands/assemble_cvd/boot_image_unpacker.h
index 05fe671..a331f0c 100644
--- a/host/commands/assemble_cvd/boot_image_unpacker.h
+++ b/host/commands/assemble_cvd/boot_image_unpacker.h
@@ -29,7 +29,9 @@
  public:
   // Reads header section of boot image at path and returns a BootImageUnpacker
   // preloaded with all the metadata.
-  static std::unique_ptr<BootImageUnpacker> FromImage(const std::string& path);
+  static std::unique_ptr<BootImageUnpacker> FromImages(
+    const std::string& boot_image_path,
+    const std::string& vendor_boot_image_path);
 
   ~BootImageUnpacker() = default;
 
@@ -37,30 +39,32 @@
 
   bool HasKernelImage() const { return kernel_image_size_ > 0; }
   bool HasRamdiskImage() const { return ramdisk_image_size_ > 0; }
-
-  // Extracts the kernel image to the given path
-  bool ExtractKernelImage(const std::string& path) const;
-  // Extracts the ramdisk image to the given path. It may return false if the
-  // boot image does not contain a ramdisk, which is the case when having system
-  // as root.
-  bool ExtractRamdiskImage(const std::string& path) const;
+  bool HasVendorRamdiskImage() const { return vendor_ramdisk_image_size_ > 0; }
 
   bool Unpack(const std::string& ramdisk_image_path,
+              const std::string& vendor_ramdisk_image_path,
               const std::string& kernel_image_path);
 
  private:
   BootImageUnpacker(SharedFD boot_image, const std::string& cmdline,
                     uint32_t kernel_image_size, uint32_t kernel_image_offset,
-                    uint32_t ramdisk_image_size, uint32_t ramdisk_image_offset)
+                    uint32_t ramdisk_image_size, uint32_t ramdisk_image_offset,
+                    SharedFD vendor_boot_image,
+                    uint32_t vendor_ramdisk_image_size,
+                    uint32_t vendor_ramdisk_image_offset)
       : boot_image_(boot_image),
+        vendor_boot_image_(vendor_boot_image),
         kernel_cmdline_(cmdline),
         kernel_image_size_(kernel_image_size),
         kernel_image_offset_(kernel_image_offset),
         ramdisk_image_size_(ramdisk_image_size),
-        ramdisk_image_offset_(ramdisk_image_offset) {}
+        ramdisk_image_offset_(ramdisk_image_offset),
+        vendor_ramdisk_image_size_(vendor_ramdisk_image_size),
+        vendor_ramdisk_image_offset_(vendor_ramdisk_image_offset) {}
 
   // Mutable because we only read from the fd, but do not modify its contents
   mutable SharedFD boot_image_;
+  mutable SharedFD vendor_boot_image_;
   std::string kernel_cmdline_;
   // When buidling the boot image a particular page size is assumed, which may
   // not match the actual page size of the system.
@@ -68,6 +72,17 @@
   uint32_t kernel_image_offset_;
   uint32_t ramdisk_image_size_;
   uint32_t ramdisk_image_offset_;
+  uint32_t vendor_ramdisk_image_size_;
+  uint32_t vendor_ramdisk_image_offset_;
+
+  // Extracts the kernel image to the given path
+  bool ExtractKernelImage(const std::string& path) const;
+  // Extracts the ramdisk image to the given path. It may return false if the
+  // boot image does not contain a ramdisk, which is the case when having system
+  // as root.
+  bool ExtractRamdiskImage(const std::string& path) const;
+  // Extracts the vendor ramdisk image to the given path
+  bool ExtractVendorRamdiskImage(const std::string& path) const;
 };
 
 }  // namespace cvd
diff --git a/host/commands/assemble_cvd/bootimg.h b/host/commands/assemble_cvd/bootimg.h
deleted file mode 100644
index 7b8fb28..0000000
--- a/host/commands/assemble_cvd/bootimg.h
+++ /dev/null
@@ -1,167 +0,0 @@
-/* tools/mkbootimg/bootimg.h
-**
-** Copyright 2007, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-// This file is a clone of the one found on system/core/mkbootimg. We've made a
-// clone because the location of the original header has changed over time.
-
-#include <stdint.h>
-
-#ifndef CUTTLEFISH_LAUNCH_BOOT_IMAGE_H_
-#define CUTTLEFISH_LAUNCH_BOOT_IMAGE_H_
-
-#define BOOT_MAGIC "ANDROID!"
-#define BOOT_MAGIC_SIZE 8
-#define BOOT_NAME_SIZE 16
-#define BOOT_ARGS_SIZE 512
-#define BOOT_EXTRA_ARGS_SIZE 1024
-
-#define BOOT_HEADER_VERSION_ZERO 0
-/*
- *  Bootloader expects the structure of boot_img_hdr with header version
- *  BOOT_HEADER_VERSION_ZERO to be as follows:
- */
-struct boot_img_hdr_v0 {
-    uint8_t magic[BOOT_MAGIC_SIZE];
-
-    uint32_t kernel_size; /* size in bytes */
-    uint32_t kernel_addr; /* physical load addr */
-
-    uint32_t ramdisk_size; /* size in bytes */
-    uint32_t ramdisk_addr; /* physical load addr */
-
-    uint32_t second_size; /* size in bytes */
-    uint32_t second_addr; /* physical load addr */
-
-    uint32_t tags_addr; /* physical addr for kernel tags */
-    uint32_t page_size; /* flash page size we assume */
-    /*
-     * version for the boot image header.
-     */
-    uint32_t header_version;
-
-    /* operating system version and security patch level; for
-     * version "A.B.C" and patch level "Y-M-D":
-     * ver = A << 14 | B << 7 | C         (7 bits for each of A, B, C)
-     * lvl = ((Y - 2000) & 127) << 4 | M  (7 bits for Y, 4 bits for M)
-     * os_version = ver << 11 | lvl */
-    uint32_t os_version;
-
-    uint8_t name[BOOT_NAME_SIZE]; /* asciiz product name */
-
-    uint8_t cmdline[BOOT_ARGS_SIZE];
-
-    uint32_t id[8]; /* timestamp / checksum / sha1 / etc */
-
-    /* Supplemental command line data; kept here to maintain
-     * binary compatibility with older versions of mkbootimg */
-    uint8_t extra_cmdline[BOOT_EXTRA_ARGS_SIZE];
-} __attribute__((packed));
-
-/*
- * It is expected that callers would explicitly specify which version of the
- * boot image header they need to use.
- */
-typedef struct boot_img_hdr_v0 boot_img_hdr;
-
-/* When a boot header is of version BOOT_HEADER_VERSION_ZERO, the structure of boot image is as
- * follows:
- *
- * +-----------------+
- * | boot header     | 1 page
- * +-----------------+
- * | kernel          | n pages
- * +-----------------+
- * | ramdisk         | m pages
- * +-----------------+
- * | second stage    | o pages
- * +-----------------+
- *
- * n = (kernel_size + page_size - 1) / page_size
- * m = (ramdisk_size + page_size - 1) / page_size
- * o = (second_size + page_size - 1) / page_size
- *
- * 0. all entities are page_size aligned in flash
- * 1. kernel and ramdisk are required (size != 0)
- * 2. second is optional (second_size == 0 -> no second)
- * 3. load each element (kernel, ramdisk, second) at
- *    the specified physical address (kernel_addr, etc)
- * 4. prepare tags at tag_addr.  kernel_args[] is
- *    appended to the kernel commandline in the tags.
- * 5. r0 = 0, r1 = MACHINE_TYPE, r2 = tags_addr
- * 6. if second_size != 0: jump to second_addr
- *    else: jump to kernel_addr
- */
-
-#define BOOT_HEADER_VERSION_ONE 1
-
-struct boot_img_hdr_v1 : public boot_img_hdr_v0 {
-    uint32_t recovery_dtbo_size;   /* size in bytes for recovery DTBO image */
-    uint64_t recovery_dtbo_offset; /* physical load addr */
-    uint32_t header_size;
-} __attribute__((packed));
-
-/* When the boot image header has a version of BOOT_HEADER_VERSION_ONE, the structure of the boot
- * image is as follows:
- *
- * +-----------------+
- * | boot header     | 1 page
- * +-----------------+
- * | kernel          | n pages
- * +-----------------+
- * | ramdisk         | m pages
- * +-----------------+
- * | second stage    | o pages
- * +-----------------+
- * | recovery dtbo   | p pages
- * +-----------------+
- * n = (kernel_size + page_size - 1) / page_size
- * m = (ramdisk_size + page_size - 1) / page_size
- * o = (second_size + page_size - 1) / page_size
- * p = (recovery_dtbo_size + page_size - 1) / page_size
- *
- * 0. all entities are page_size aligned in flash
- * 1. kernel and ramdisk are required (size != 0)
- * 2. recovery_dtbo is required for recovery.img in non-A/B devices(recovery_dtbo_size != 0)
- * 3. second is optional (second_size == 0 -> no second)
- * 4. load each element (kernel, ramdisk, second, recovery_dtbo) at
- *    the specified physical address (kernel_addr, etc)
- * 5. prepare tags at tag_addr.  kernel_args[] is
- *    appended to the kernel commandline in the tags.
- * 6. r0 = 0, r1 = MACHINE_TYPE, r2 = tags_addr
- * 7. if second_size != 0: jump to second_addr
- *    else: jump to kernel_addr
- */
-
-#if 0
-typedef struct ptentry ptentry;
-
-struct ptentry {
-    char name[16];      /* asciiz partition name    */
-    unsigned start;     /* starting block number    */
-    unsigned length;    /* length in blocks         */
-    unsigned flags;     /* set to zero              */
-};
-
-/* MSM Partition Table ATAG
-**
-** length: 2 + 7 * n
-** atag:   0x4d534d70
-**         <ptentry> x n
-*/
-#endif
-
-#endif
diff --git a/host/commands/assemble_cvd/flags.cc b/host/commands/assemble_cvd/flags.cc
index 6de4abd..22def1b 100644
--- a/host/commands/assemble_cvd/flags.cc
+++ b/host/commands/assemble_cvd/flags.cc
@@ -71,6 +71,9 @@
 DEFINE_string(boot_image, "",
               "Location of cuttlefish boot image. If empty it is assumed to be "
               "boot.img in the directory specified by -system_image_dir.");
+DEFINE_string(vendor_boot_image, "",
+              "Location of cuttlefish vendor boot image. If empty it is assumed to "
+              "be vendor_boot.img in the directory specified by -system_image_dir.");
 DEFINE_int32(memory_mb, 2048,
              "Total amount of memory available for guest, MB.");
 std::string g_default_mempath{vsoc::GetDefaultMempath()};
@@ -251,6 +254,11 @@
   std::string default_composite_disk = FLAGS_system_image_dir + "/composite.img";
   SetCommandLineOptionWithMode("composite_disk", default_composite_disk.c_str(),
                                google::FlagSettingMode::SET_FLAGS_DEFAULT);
+  std::string default_vendor_boot_image = FLAGS_system_image_dir
+                                        + "/vendor_boot.img";
+  SetCommandLineOptionWithMode("vendor_boot_image",
+                               default_vendor_boot_image.c_str(),
+                               google::FlagSettingMode::SET_FLAGS_DEFAULT);
 
   return true;
 }
@@ -325,10 +333,12 @@
   }
 
   auto ramdisk_path = tmp_config_obj.PerInstancePath("ramdisk.img");
+  auto vendor_ramdisk_path = tmp_config_obj.PerInstancePath("vendor_ramdisk.img");
   bool use_ramdisk = boot_image_unpacker.HasRamdiskImage();
   if (!use_ramdisk) {
     LOG(INFO) << "No ramdisk present; assuming system-as-root build";
     ramdisk_path = "";
+    vendor_ramdisk_path = "";
   }
 
   tmp_config_obj.add_kernel_cmdline(boot_image_unpacker.kernel_cmdline());
@@ -405,11 +415,12 @@
   }
 
   tmp_config_obj.set_ramdisk_image_path(ramdisk_path);
+  // Boot as recovery is set so normal boot needs to be forced every boot
+  tmp_config_obj.add_kernel_cmdline("androidboot.force_normal_boot=1");
+  tmp_config_obj.set_vendor_ramdisk_image_path(vendor_ramdisk_path);
+  tmp_config_obj.set_final_ramdisk_path(ramdisk_path + kRamdiskConcatExt);
   if(FLAGS_initramfs_path.size() > 0) {
     tmp_config_obj.set_initramfs_path(FLAGS_initramfs_path);
-    tmp_config_obj.set_final_ramdisk_path(ramdisk_path + kRamdiskConcatExt);
-  } else {
-    tmp_config_obj.set_final_ramdisk_path(ramdisk_path);
   }
 
   tmp_config_obj.set_mempath(FLAGS_mempath);
@@ -791,7 +802,14 @@
     exit(cvd::kCuttlefishConfigurationInitError);
   }
 
-  auto boot_img_unpacker = cvd::BootImageUnpacker::FromImage(FLAGS_boot_image);
+  if (!cvd::FileHasContent(FLAGS_vendor_boot_image)) {
+    LOG(ERROR) << "File not found: " << FLAGS_vendor_boot_image;
+    exit(cvd::kCuttlefishConfigurationInitError);
+  }
+
+  auto boot_img_unpacker =
+    cvd::BootImageUnpacker::FromImages(FLAGS_boot_image,
+                                       FLAGS_vendor_boot_image);
 
   if (!InitializeCuttlefishConfiguration(*boot_img_unpacker)) {
     LOG(ERROR) << "Failed to initialize configuration";
@@ -805,6 +823,7 @@
   }
 
   if (!boot_img_unpacker->Unpack(config->ramdisk_image_path(),
+                                 config->vendor_ramdisk_image_path(),
                                  config->use_unpacked_kernel()
                                      ? config->kernel_image_path()
                                      : "")) {
@@ -812,12 +831,20 @@
     exit(AssemblerExitCodes::kBootImageUnpackError);
   }
 
-  if(config->initramfs_path().size() != 0) {
-    if(!ConcatRamdisks(config->final_ramdisk_path(), config->ramdisk_image_path(),
-        config->initramfs_path())) {
-      LOG(ERROR) << "Failed to concatenate ramdisk and initramfs";
-      exit(AssemblerExitCodes::kInitRamFsConcatError);
-    }
+  // TODO(134522463) as part of the bootloader refactor, repack the vendor boot
+  // image and use the bootloader to load both the boot and vendor ramdisk.
+  // Until then, this hack to get gki modules into cuttlefish will suffice.
+
+  // If a vendor ramdisk comes in via this mechanism, let it supercede the one
+  // in the vendor boot image. This flag is what kernel presubmit testing uses
+  // to pass in the kernel ramdisk.
+  const std::string& vendor_ramdisk_path = config->initramfs_path().size() ?
+                                           config->initramfs_path() :
+                                           config->vendor_ramdisk_image_path();
+  if(!ConcatRamdisks(config->final_ramdisk_path(), config->ramdisk_image_path(),
+                     vendor_ramdisk_path)) {
+    LOG(ERROR) << "Failed to concatenate ramdisk and vendor ramdisk";
+    exit(AssemblerExitCodes::kInitRamFsConcatError);
   }
 
   if (config->decompress_kernel()) {
diff --git a/host/libs/config/cuttlefish_config.cpp b/host/libs/config/cuttlefish_config.cpp
index ade685b..882a951 100644
--- a/host/libs/config/cuttlefish_config.cpp
+++ b/host/libs/config/cuttlefish_config.cpp
@@ -92,6 +92,7 @@
 const char* kRamdiskImagePath = "ramdisk_image_path";
 const char* kInitramfsPath = "initramfs_path";
 const char* kFinalRamdiskPath = "final_ramdisk_path";
+const char* kVendorRamdiskImagePath = "vendor_ramdisk_image_path";
 
 const char* kVirtualDiskPaths = "virtual_disk_paths";
 const char* kUsbV1SocketName = "usb_v1_socket_name";
@@ -380,6 +381,14 @@
   SetPath(kFinalRamdiskPath, final_ramdisk_path);
 }
 
+std::string CuttlefishConfig::vendor_ramdisk_image_path() const {
+  return (*dictionary_)[kVendorRamdiskImagePath].asString();
+}
+void CuttlefishConfig::set_vendor_ramdisk_image_path(
+    const std::string& vendor_ramdisk_image_path) {
+  SetPath(kVendorRamdiskImagePath, vendor_ramdisk_image_path);
+}
+
 std::vector<std::string> CuttlefishConfig::virtual_disk_paths() const {
   std::vector<std::string> virtual_disks;
   auto virtual_disks_json_obj = (*dictionary_)[kVirtualDiskPaths];
diff --git a/host/libs/config/cuttlefish_config.h b/host/libs/config/cuttlefish_config.h
index 09ae4a9..0fca9f0 100644
--- a/host/libs/config/cuttlefish_config.h
+++ b/host/libs/config/cuttlefish_config.h
@@ -156,6 +156,10 @@
   std::string final_ramdisk_path() const;
   void set_final_ramdisk_path(const std::string& final_ramdisk_path);
 
+  std::string vendor_ramdisk_image_path() const;
+  void set_vendor_ramdisk_image_path(const std::string&
+    vendor_ramdisk_image_path);
+
   std::vector<std::string> virtual_disk_paths() const;
   void set_virtual_disk_paths(const std::vector<std::string>& disk_paths);