diff --git a/common/libs/device_config/device_config.h b/common/libs/device_config/device_config.h
index bbd74d1..6db45e6 100644
--- a/common/libs/device_config/device_config.h
+++ b/common/libs/device_config/device_config.h
@@ -76,8 +76,8 @@
   void generate_address_and_prefix();
 #ifdef CUTTLEFISH_HOST
   DeviceConfig() = default;
-  bool InitializeNetworkConfiguration(const vsoc::CuttlefishConfig& config);
-  void InitializeScreenConfiguration(const vsoc::CuttlefishConfig& config);
+  bool InitializeNetworkConfiguration(const cuttlefish::CuttlefishConfig& config);
+  void InitializeScreenConfiguration(const cuttlefish::CuttlefishConfig& config);
 #else
   explicit DeviceConfig(const RawData& data);
 #endif
diff --git a/common/libs/device_config/host_device_config.cpp b/common/libs/device_config/host_device_config.cpp
index 0a3f0a0..9a9b3ba 100644
--- a/common/libs/device_config/host_device_config.cpp
+++ b/common/libs/device_config/host_device_config.cpp
@@ -139,7 +139,7 @@
 }  // namespace
 
 std::unique_ptr<DeviceConfig> DeviceConfig::Get() {
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   if (!config) return nullptr;
   std::unique_ptr<DeviceConfig> dev_config(new DeviceConfig());
   if (!dev_config->InitializeNetworkConfiguration(*config)) {
@@ -150,7 +150,7 @@
 }
 
 bool DeviceConfig::InitializeNetworkConfiguration(
-    const vsoc::CuttlefishConfig& config) {
+    const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   NetConfig netconfig;
   // Check the mobile bridge first; this was the traditional way we configured
@@ -184,7 +184,7 @@
 }
 
 void DeviceConfig::InitializeScreenConfiguration(
-    const vsoc::CuttlefishConfig& config) {
+    const cuttlefish::CuttlefishConfig& config) {
   data_.screen.x_res = config.x_res();
   data_.screen.y_res = config.y_res();
   data_.screen.dpi = config.dpi();
diff --git a/guest/commands/vsoc_input_service/main.cpp b/guest/commands/vsoc_input_service/main.cpp
index c9e93ed..65d6c6c 100644
--- a/guest/commands/vsoc_input_service/main.cpp
+++ b/guest/commands/vsoc_input_service/main.cpp
@@ -21,7 +21,7 @@
 
 int main(int argc, char* argv[]) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
-  vsoc_input_service::VSoCInputService service;
+  cuttlefish_input_service::VSoCInputService service;
   if (!service.SetUpDevices()) {
     return -1;
   }
diff --git a/guest/commands/vsoc_input_service/virtual_device_base.cpp b/guest/commands/vsoc_input_service/virtual_device_base.cpp
index 6bfd6c6..b96ee39 100644
--- a/guest/commands/vsoc_input_service/virtual_device_base.cpp
+++ b/guest/commands/vsoc_input_service/virtual_device_base.cpp
@@ -25,7 +25,7 @@
 
 #include "log/log.h"
 
-using vsoc_input_service::VirtualDeviceBase;
+using cuttlefish_input_service::VirtualDeviceBase;
 
 namespace {
 
diff --git a/guest/commands/vsoc_input_service/virtual_device_base.h b/guest/commands/vsoc_input_service/virtual_device_base.h
index d25e0e4..2932753 100644
--- a/guest/commands/vsoc_input_service/virtual_device_base.h
+++ b/guest/commands/vsoc_input_service/virtual_device_base.h
@@ -22,7 +22,7 @@
 #include <functional>
 #include <vector>
 
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
 
 class VirtualDeviceBase {
  public:
@@ -48,4 +48,4 @@
   int fd_ = -1;
 };
 
-}  // namespace vsoc_input_service
+}  // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_keyboard.cpp b/guest/commands/vsoc_input_service/virtual_keyboard.cpp
index 80cf0e0..7ffcea5 100644
--- a/guest/commands/vsoc_input_service/virtual_keyboard.cpp
+++ b/guest/commands/vsoc_input_service/virtual_keyboard.cpp
@@ -16,7 +16,7 @@
 
 #include "virtual_keyboard.h"
 
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
 
 VirtualKeyboard::VirtualKeyboard()
     : VirtualDeviceBase("VSoC keyboard", 0x6008) {}
@@ -63,4 +63,4 @@
   return keys;
 }
 
-}  // namespace vsoc_input_service
+}  // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_keyboard.h b/guest/commands/vsoc_input_service/virtual_keyboard.h
index b343699..0dd1f42 100644
--- a/guest/commands/vsoc_input_service/virtual_keyboard.h
+++ b/guest/commands/vsoc_input_service/virtual_keyboard.h
@@ -17,7 +17,7 @@
 
 #include "virtual_device_base.h"
 
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
 
 class VirtualKeyboard : public VirtualDeviceBase {
  public:
@@ -28,4 +28,4 @@
   const std::vector<const uint32_t>& GetKeys() const override;
 };
 
-}  // namespace vsoc_input_service
+}  // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_power_button.cpp b/guest/commands/vsoc_input_service/virtual_power_button.cpp
index d1758e0..595630b 100644
--- a/guest/commands/vsoc_input_service/virtual_power_button.cpp
+++ b/guest/commands/vsoc_input_service/virtual_power_button.cpp
@@ -16,7 +16,7 @@
 
 #include "virtual_power_button.h"
 
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
 
 VirtualPowerButton::VirtualPowerButton()
     : VirtualDeviceBase("VSoC power button", 0x6007) {}
@@ -30,4 +30,4 @@
   return keys;
 }
 
-}  // namespace vsoc_input_service
+}  // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_power_button.h b/guest/commands/vsoc_input_service/virtual_power_button.h
index 220bfdc..95811db 100644
--- a/guest/commands/vsoc_input_service/virtual_power_button.h
+++ b/guest/commands/vsoc_input_service/virtual_power_button.h
@@ -17,7 +17,7 @@
 
 #include "virtual_device_base.h"
 
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
 
 class VirtualPowerButton : public VirtualDeviceBase {
  public:
@@ -28,4 +28,4 @@
   const std::vector<const uint32_t>& GetKeys() const override;
 };
 
-}  // namespace vsoc_input_service
+}  // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_touchscreen.cpp b/guest/commands/vsoc_input_service/virtual_touchscreen.cpp
index 72a0d3f..c678573 100644
--- a/guest/commands/vsoc_input_service/virtual_touchscreen.cpp
+++ b/guest/commands/vsoc_input_service/virtual_touchscreen.cpp
@@ -16,7 +16,7 @@
 
 #include "virtual_touchscreen.h"
 
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
 
 const std::vector<const uint32_t>& VirtualTouchScreen::GetEventTypes() const {
   static const std::vector<const uint32_t> evt_types{EV_ABS, EV_KEY};
@@ -43,4 +43,4 @@
   dev_.absmax[ABS_Y] = height;
 }
 
-}  // namespace vsoc_input_service
+}  // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/virtual_touchscreen.h b/guest/commands/vsoc_input_service/virtual_touchscreen.h
index 9ac806e..a32bcb5 100644
--- a/guest/commands/vsoc_input_service/virtual_touchscreen.h
+++ b/guest/commands/vsoc_input_service/virtual_touchscreen.h
@@ -17,7 +17,7 @@
 
 #include "virtual_device_base.h"
 
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
 
 class VirtualTouchScreen : public VirtualDeviceBase {
  public:
@@ -30,4 +30,4 @@
   virtual const std::vector<const uint32_t>& GetAbs() const;
 };
 
-}  // namespace vsoc_input_service
+}  // namespace cuttlefish_input_service
diff --git a/guest/commands/vsoc_input_service/vsoc_input_service.cpp b/guest/commands/vsoc_input_service/vsoc_input_service.cpp
index 0cb56ef..acda3c1 100644
--- a/guest/commands/vsoc_input_service/vsoc_input_service.cpp
+++ b/guest/commands/vsoc_input_service/vsoc_input_service.cpp
@@ -29,12 +29,12 @@
 #include "common/libs/fs/shared_fd.h"
 #include "common/libs/device_config/device_config.h"
 
-using vsoc::input_events::InputEvent;
-using vsoc_input_service::VirtualDeviceBase;
-using vsoc_input_service::VirtualKeyboard;
-using vsoc_input_service::VirtualPowerButton;
-using vsoc_input_service::VirtualTouchScreen;
-using vsoc_input_service::VSoCInputService;
+using cuttlefish::input_events::InputEvent;
+using cuttlefish_input_service::VirtualDeviceBase;
+using cuttlefish_input_service::VirtualKeyboard;
+using cuttlefish_input_service::VirtualPowerButton;
+using cuttlefish_input_service::VirtualTouchScreen;
+using cuttlefish_input_service::VSoCInputService;
 
 DEFINE_uint32(keyboard_port, 0, "keyboard vsock port");
 DEFINE_uint32(touch_port, 0, "keyboard vsock port");
diff --git a/guest/commands/vsoc_input_service/vsoc_input_service.h b/guest/commands/vsoc_input_service/vsoc_input_service.h
index edf196d..d8aea81 100644
--- a/guest/commands/vsoc_input_service/vsoc_input_service.h
+++ b/guest/commands/vsoc_input_service/vsoc_input_service.h
@@ -21,7 +21,7 @@
 #include "virtual_power_button.h"
 #include "virtual_touchscreen.h"
 
-namespace vsoc {
+namespace cuttlefish {
 namespace input_events {
 
 struct InputEvent {
@@ -31,9 +31,9 @@
 };
 
 } // namespace input_events
-} // namespace vsoc
+} // namespace cuttlefish
 
-namespace vsoc_input_service {
+namespace cuttlefish_input_service {
 
 class VSoCInputService {
  public:
@@ -46,4 +46,4 @@
   std::shared_ptr<VirtualTouchScreen> virtual_touchscreen_;
 };
 
-}  // namespace vsoc_input_service
+}  // namespace cuttlefish_input_service
diff --git a/guest/hals/gralloc/legacy/gralloc.cpp b/guest/hals/gralloc/legacy/gralloc.cpp
index 28e71eb..2da3ac9 100644
--- a/guest/hals/gralloc/legacy/gralloc.cpp
+++ b/guest/hals/gralloc/legacy/gralloc.cpp
@@ -38,7 +38,7 @@
 #include "gralloc_vsoc_priv.h"
 #include "region_registry.h"
 
-using vsoc::screen::ScreenRegionView;
+using cuttlefish::screen::ScreenRegionView;
 
 /*****************************************************************************/
 
diff --git a/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h b/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
index 390c654..987a092 100644
--- a/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
+++ b/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
@@ -43,7 +43,7 @@
 };
 #endif
 
-namespace vsoc {
+namespace cuttlefish {
 namespace screen {
 
 struct ScreenRegionView {
@@ -258,9 +258,9 @@
 #ifdef GRALLOC_MODULE_API_VERSION_0_2
     case HAL_PIXEL_FORMAT_YCbCr_420_888:
 #endif
-      out->ystride = vsoc::screen::ScreenRegionView::align(width);
+      out->ystride = cuttlefish::screen::ScreenRegionView::align(width);
       out->cstride =
-          vsoc::screen::ScreenRegionView::align(out->ystride / 2);
+          cuttlefish::screen::ScreenRegionView::align(out->ystride / 2);
       out->chroma_step = 1;
       out->y = it;
       it += out->ystride * height;
@@ -295,17 +295,17 @@
       y_size = strides.ystride * h;
       c_size = strides.cstride * h / 2;
       return (y_size + 2 * c_size +
-              vsoc::screen::ScreenRegionView::kSwiftShaderPadding);
+              cuttlefish::screen::ScreenRegionView::kSwiftShaderPadding);
     /*case HAL_PIXEL_FORMAT_RGBA_8888:
     case HAL_PIXEL_FORMAT_RGBX_8888:
     case HAL_PIXEL_FORMAT_BGRA_8888:
     case HAL_PIXEL_FORMAT_RGB_888:
     case HAL_PIXEL_FORMAT_RGB_565:*/
     default:
-      w16 = vsoc::screen::ScreenRegionView::align(w);
-      h16 = vsoc::screen::ScreenRegionView::align(h);
+      w16 = cuttlefish::screen::ScreenRegionView::align(w);
+      h16 = cuttlefish::screen::ScreenRegionView::align(h);
       return bytes_per_pixel * w16 * h16 +
-             vsoc::screen::ScreenRegionView::kSwiftShaderPadding;
+             cuttlefish::screen::ScreenRegionView::kSwiftShaderPadding;
   }
 }
 
diff --git a/host/commands/adbshell/main.cpp b/host/commands/adbshell/main.cpp
index 95f5fef..f971ab5 100644
--- a/host/commands/adbshell/main.cpp
+++ b/host/commands/adbshell/main.cpp
@@ -57,7 +57,7 @@
 
   std::string cvd_prefix = "cvd-";
   if (user.find(cvd_prefix) == 0) {
-    user.replace(0, cvd_prefix.size(), vsoc::kVsocUserPrefix);
+    user.replace(0, cvd_prefix.size(), cuttlefish::kVsocUserPrefix);
   }
   return user;
 }
@@ -76,14 +76,14 @@
 }
 
 void SetCuttlefishConfigEnv() {
-  setenv(vsoc::kCuttlefishConfigEnvVarName, CuttlefishConfigLocation().c_str(),
+  setenv(cuttlefish::kCuttlefishConfigEnvVarName, CuttlefishConfigLocation().c_str(),
          true);
 }
 }  // namespace
 
 int main(int argc, char* argv[]) {
   SetCuttlefishConfigEnv();
-  auto instance = vsoc::CuttlefishConfig::Get()
+  auto instance = cuttlefish::CuttlefishConfig::Get()
       ->ForDefaultInstance().adb_device_name();
   std::string adb_path = CuttlefishFindAdb();
 
diff --git a/host/commands/assemble_cvd/boot_config.cc b/host/commands/assemble_cvd/boot_config.cc
index bdfdf09..7e1171c 100644
--- a/host/commands/assemble_cvd/boot_config.cc
+++ b/host/commands/assemble_cvd/boot_config.cc
@@ -32,7 +32,7 @@
 
 namespace {
 
-size_t WriteEnvironment(const vsoc::CuttlefishConfig& config,
+size_t WriteEnvironment(const cuttlefish::CuttlefishConfig& config,
                         const std::string& env_path) {
   std::ostringstream env;
   auto kernel_args = KernelCommandLineFromConfig(config);
@@ -58,7 +58,7 @@
 }  // namespace
 
 
-bool InitBootloaderEnvPartition(const vsoc::CuttlefishConfig& config,
+bool InitBootloaderEnvPartition(const cuttlefish::CuttlefishConfig& config,
                                 const std::string& boot_env_image_path) {
   auto tmp_boot_env_image_path = boot_env_image_path + ".tmp";
   auto uboot_env_path = config.AssemblyPath("u-boot.env");
@@ -67,7 +67,7 @@
     return false;
   }
 
-  auto mkimage_path = vsoc::DefaultHostArtifactsPath("bin/mkenvimage");
+  auto mkimage_path = cuttlefish::DefaultHostArtifactsPath("bin/mkenvimage");
   cuttlefish::Command cmd(mkimage_path);
   cmd.AddParameter("-s");
   cmd.AddParameter("4096");
diff --git a/host/commands/assemble_cvd/boot_config.h b/host/commands/assemble_cvd/boot_config.h
index a7b6a12..8a3148c 100644
--- a/host/commands/assemble_cvd/boot_config.h
+++ b/host/commands/assemble_cvd/boot_config.h
@@ -18,5 +18,5 @@
 #include <string>
 #include <host/libs/config/cuttlefish_config.h>
 
-bool InitBootloaderEnvPartition(const vsoc::CuttlefishConfig& config,
+bool InitBootloaderEnvPartition(const cuttlefish::CuttlefishConfig& config,
                                 const std::string& boot_env_image_path);
diff --git a/host/commands/assemble_cvd/data_image.cc b/host/commands/assemble_cvd/data_image.cc
index 60d05a1..b1f050e 100644
--- a/host/commands/assemble_cvd/data_image.cc
+++ b/host/commands/assemble_cvd/data_image.cc
@@ -19,7 +19,7 @@
 const int FSCK_ERROR_CORRECTED_REQUIRES_REBOOT = 2;
 
 bool ForceFsckImage(const char* data_image) {
-  auto fsck_path = vsoc::DefaultHostArtifactsPath("bin/fsck.f2fs");
+  auto fsck_path = cuttlefish::DefaultHostArtifactsPath("bin/fsck.f2fs");
   int fsck_status = cuttlefish::execute({fsck_path, "-y", "-f", data_image});
   if (fsck_status & ~(FSCK_ERROR_CORRECTED|FSCK_ERROR_CORRECTED_REQUIRES_REBOOT)) {
     LOG(ERROR) << "`fsck.f2fs -y -f " << data_image << "` failed with code "
@@ -50,7 +50,7 @@
     if (!fsck_success) {
       return false;
     }
-    auto resize_path = vsoc::DefaultHostArtifactsPath("bin/resize.f2fs");
+    auto resize_path = cuttlefish::DefaultHostArtifactsPath("bin/resize.f2fs");
     int resize_status = cuttlefish::execute({resize_path, data_image});
     if (resize_status != 0) {
       LOG(ERROR) << "`resize.f2fs " << data_image << "` failed with code "
@@ -85,7 +85,7 @@
   if (image_fmt == "ext4") {
     cuttlefish::execute({"/sbin/mkfs.ext4", image});
   } else if (image_fmt == "f2fs") {
-    auto make_f2fs_path = vsoc::DefaultHostArtifactsPath("bin/make_f2fs");
+    auto make_f2fs_path = cuttlefish::DefaultHostArtifactsPath("bin/make_f2fs");
     cuttlefish::execute({make_f2fs_path, "-t", image_fmt, image, "-g", "android"});
   } else if (image_fmt == "sdcard") {
     // Reserve 1MB in the image for the MBR and padding, to simulate what
@@ -93,7 +93,7 @@
     off_t offset_size_bytes = 1 << 20;
     image_size_bytes -= offset_size_bytes;
     off_t image_size_sectors = image_size_bytes / 512;
-    auto newfs_msdos_path = vsoc::DefaultHostArtifactsPath("bin/newfs_msdos");
+    auto newfs_msdos_path = cuttlefish::DefaultHostArtifactsPath("bin/newfs_msdos");
     cuttlefish::execute({newfs_msdos_path, "-F", "32", "-m", "0xf8", "-a", "4088",
                                     "-o", "0",  "-c", "8",    "-h", "255",
                                     "-u", "63", "-S", "512",
@@ -122,7 +122,7 @@
   }
 }
 
-DataImageResult ApplyDataImagePolicy(const vsoc::CuttlefishConfig& config,
+DataImageResult ApplyDataImagePolicy(const cuttlefish::CuttlefishConfig& config,
                                      const std::string& data_image) {
   bool data_exists = cuttlefish::FileHasContent(data_image.c_str());
   bool remove{};
diff --git a/host/commands/assemble_cvd/data_image.h b/host/commands/assemble_cvd/data_image.h
index e4afdf8..b7b626b 100644
--- a/host/commands/assemble_cvd/data_image.h
+++ b/host/commands/assemble_cvd/data_image.h
@@ -10,7 +10,7 @@
   FileUpdated,
 };
 
-DataImageResult ApplyDataImagePolicy(const vsoc::CuttlefishConfig& config,
+DataImageResult ApplyDataImagePolicy(const cuttlefish::CuttlefishConfig& config,
                                      const std::string& path);
 bool InitializeMiscImage(const std::string& misc_image);
 void CreateBlankImage(
diff --git a/host/commands/assemble_cvd/flags.cc b/host/commands/assemble_cvd/flags.cc
index a018c2a..9572102 100644
--- a/host/commands/assemble_cvd/flags.cc
+++ b/host/commands/assemble_cvd/flags.cc
@@ -34,7 +34,7 @@
 // Taken from external/avb/libavb/avb_slot_verify.c; this define is not in the headers
 #define VBMETA_MAX_SIZE 65536ul
 
-using vsoc::ForCurrentInstance;
+using cuttlefish::ForCurrentInstance;
 using cuttlefish::AssemblerExitCodes;
 
 DEFINE_string(cache_image, "", "Location of the cache partition image.");
@@ -91,7 +91,7 @@
 DEFINE_string(serial_number, ForCurrentInstance("CUTTLEFISHCVD"),
               "Serial number to use for the device");
 DEFINE_string(assembly_dir,
-              vsoc::DefaultHostArtifactsPath("cuttlefish_assembly"),
+              cuttlefish::DefaultHostArtifactsPath("cuttlefish_assembly"),
               "A directory to put generated files common between instances");
 DEFINE_string(instance_dir,
               cuttlefish::StringFromEnv("HOME", ".") + "/cuttlefish_runtime",
@@ -100,10 +100,10 @@
     vm_manager, vm_manager::CrosvmManager::name(),
     "What virtual machine manager to use, one of {qemu_cli, crosvm}");
 DEFINE_string(
-    gpu_mode, vsoc::kGpuModeGuestSwiftshader,
+    gpu_mode, cuttlefish::kGpuModeGuestSwiftshader,
     "What gpu configuration to use, one of {guest_swiftshader, drm_virgl}");
 
-DEFINE_string(system_image_dir, vsoc::DefaultGuestImagePath(""),
+DEFINE_string(system_image_dir, cuttlefish::DefaultGuestImagePath(""),
               "Location of the system partition images.");
 DEFINE_string(super_image, "", "Location of the super partition image.");
 DEFINE_string(misc_image, "",
@@ -144,19 +144,19 @@
 static const std::string kSeccompDir =
     std::string("usr/share/cuttlefish/") + cuttlefish::HostArch() + "-linux-gnu/seccomp";
 DEFINE_string(seccomp_policy_dir,
-              vsoc::DefaultHostArtifactsPath(kSeccompDir),
+              cuttlefish::DefaultHostArtifactsPath(kSeccompDir),
               "With sandbox'ed crosvm, overrieds the security comp policy directory");
 
 DEFINE_bool(start_webrtc, false, "Whether to start the webrtc process.");
 
 DEFINE_string(
         webrtc_assets_dir,
-        vsoc::DefaultHostArtifactsPath("usr/share/webrtc/assets"),
+        cuttlefish::DefaultHostArtifactsPath("usr/share/webrtc/assets"),
         "[Experimental] Path to WebRTC webpage assets.");
 
 DEFINE_string(
         webrtc_certs_dir,
-        vsoc::DefaultHostArtifactsPath("usr/share/webrtc/certs"),
+        cuttlefish::DefaultHostArtifactsPath("usr/share/webrtc/certs"),
         "[Experimental] Path to WebRTC certificates directory.");
 
 DEFINE_string(
@@ -209,7 +209,7 @@
             "Maintain adb connection by sending 'adb connect' commands to the "
             "server. Only relevant with -adb_mode=tunnel or vsock_tunnel");
 
-DEFINE_string(uuid, vsoc::ForCurrentInstance(vsoc::kDefaultUuidPrefix),
+DEFINE_string(uuid, cuttlefish::ForCurrentInstance(cuttlefish::kDefaultUuidPrefix),
               "UUID to use for the device. Random if not specified");
 DEFINE_bool(daemon, false,
             "Run cuttlefish in background, the launcher exits on boot "
@@ -224,7 +224,7 @@
               "/usr/bin/qemu-system-x86_64",
               "The qemu binary to use");
 DEFINE_string(crosvm_binary,
-              vsoc::DefaultHostArtifactsPath("bin/crosvm"),
+              cuttlefish::DefaultHostArtifactsPath("bin/crosvm"),
               "The Crosvm binary to use");
 DEFINE_string(tpm_binary, "",
               "The TPM simulator to use. Disabled if empty.");
@@ -319,13 +319,13 @@
 
 // Initializes the config object and saves it to file. It doesn't return it, all
 // further uses of the config should happen through the singleton
-vsoc::CuttlefishConfig InitializeCuttlefishConfiguration(
+cuttlefish::CuttlefishConfig InitializeCuttlefishConfiguration(
     const cuttlefish::BootImageUnpacker& boot_image_unpacker,
     const cuttlefish::FetcherConfig& fetcher_config) {
   // At most one streamer can be started.
   CHECK(NumStreamers() <= 1);
 
-  vsoc::CuttlefishConfig tmp_config_obj;
+  cuttlefish::CuttlefishConfig tmp_config_obj;
   tmp_config_obj.set_assembly_dir(FLAGS_assembly_dir);
   if (!vm_manager::VmManager::IsValidName(FLAGS_vm_manager)) {
     LOG(FATAL) << "Invalid vm_manager: " << FLAGS_vm_manager;
@@ -403,22 +403,22 @@
 
   tmp_config_obj.set_deprecated_boot_completed(FLAGS_deprecated_boot_completed);
   tmp_config_obj.set_logcat_receiver_binary(
-      vsoc::DefaultHostArtifactsPath("bin/logcat_receiver"));
+      cuttlefish::DefaultHostArtifactsPath("bin/logcat_receiver"));
   tmp_config_obj.set_config_server_binary(
-      vsoc::DefaultHostArtifactsPath("bin/config_server"));
+      cuttlefish::DefaultHostArtifactsPath("bin/config_server"));
 
   tmp_config_obj.set_qemu_binary(FLAGS_qemu_binary);
   tmp_config_obj.set_crosvm_binary(FLAGS_crosvm_binary);
   tmp_config_obj.set_tpm_binary(FLAGS_tpm_binary);
   tmp_config_obj.set_tpm_device(FLAGS_tpm_device);
   tmp_config_obj.set_console_forwarder_binary(
-      vsoc::DefaultHostArtifactsPath("bin/console_forwarder"));
+      cuttlefish::DefaultHostArtifactsPath("bin/console_forwarder"));
   tmp_config_obj.set_kernel_log_monitor_binary(
-      vsoc::DefaultHostArtifactsPath("bin/kernel_log_monitor"));
+      cuttlefish::DefaultHostArtifactsPath("bin/kernel_log_monitor"));
 
   tmp_config_obj.set_enable_vnc_server(FLAGS_start_vnc_server);
   tmp_config_obj.set_vnc_server_binary(
-      vsoc::DefaultHostArtifactsPath("bin/vnc_server"));
+      cuttlefish::DefaultHostArtifactsPath("bin/vnc_server"));
 
   tmp_config_obj.set_enable_sandbox(FLAGS_enable_sandbox);
 
@@ -426,12 +426,12 @@
 
   tmp_config_obj.set_enable_webrtc(FLAGS_start_webrtc);
   tmp_config_obj.set_webrtc_binary(
-      vsoc::DefaultHostArtifactsPath("bin/webRTC"));
+      cuttlefish::DefaultHostArtifactsPath("bin/webRTC"));
   tmp_config_obj.set_webrtc_assets_dir(FLAGS_webrtc_assets_dir);
   tmp_config_obj.set_webrtc_public_ip(FLAGS_webrtc_public_ip);
   tmp_config_obj.set_webrtc_certs_dir(FLAGS_webrtc_certs_dir);
   tmp_config_obj.set_sig_server_binary(
-      vsoc::DefaultHostArtifactsPath("bin/webrtc_sig_server"));
+      cuttlefish::DefaultHostArtifactsPath("bin/webrtc_sig_server"));
   // Note: This will be overridden if the sig server is started by us
   tmp_config_obj.set_sig_server_port(FLAGS_webrtc_sig_server_port);
   tmp_config_obj.set_sig_server_address(FLAGS_webrtc_sig_server_addr);
@@ -444,9 +444,9 @@
   tmp_config_obj.set_restart_subprocesses(FLAGS_restart_subprocesses);
   tmp_config_obj.set_run_adb_connector(FLAGS_run_adb_connector);
   tmp_config_obj.set_adb_connector_binary(
-      vsoc::DefaultHostArtifactsPath("bin/adb_connector"));
+      cuttlefish::DefaultHostArtifactsPath("bin/adb_connector"));
   tmp_config_obj.set_socket_vsock_proxy_binary(
-      vsoc::DefaultHostArtifactsPath("bin/socket_vsock_proxy"));
+      cuttlefish::DefaultHostArtifactsPath("bin/socket_vsock_proxy"));
   tmp_config_obj.set_run_as_daemon(FLAGS_daemon);
 
   tmp_config_obj.set_data_policy(FLAGS_data_policy);
@@ -457,14 +457,14 @@
 
   tmp_config_obj.set_enable_tombstone_receiver(FLAGS_enable_tombstone_receiver);
   tmp_config_obj.set_tombstone_receiver_binary(
-      vsoc::DefaultHostArtifactsPath("bin/tombstone_receiver"));
+      cuttlefish::DefaultHostArtifactsPath("bin/tombstone_receiver"));
 
   tmp_config_obj.set_use_bootloader(FLAGS_use_bootloader);
   tmp_config_obj.set_bootloader(FLAGS_bootloader);
 
   tmp_config_obj.set_enable_metrics(FLAGS_report_anonymous_usage_stats);
   tmp_config_obj.set_metrics_binary(
-      vsoc::DefaultHostArtifactsPath("bin/metrics"));
+      cuttlefish::DefaultHostArtifactsPath("bin/metrics"));
 
   if (!FLAGS_boot_slot.empty()) {
       tmp_config_obj.set_boot_slot(FLAGS_boot_slot);
@@ -476,13 +476,13 @@
 
   std::vector<int> instance_nums;
   for (int i = 0; i < FLAGS_num_instances; i++) {
-    instance_nums.push_back(vsoc::GetInstance() + i);
+    instance_nums.push_back(cuttlefish::GetInstance() + i);
   }
 
   bool is_first_instance = true;
   for (const auto& num : instance_nums) {
     auto instance = tmp_config_obj.ForInstance(num);
-    auto const_instance = const_cast<const vsoc::CuttlefishConfig&>(tmp_config_obj)
+    auto const_instance = const_cast<const cuttlefish::CuttlefishConfig&>(tmp_config_obj)
         .ForInstance(num);
     // Set this first so that calls to PerInstancePath below are correct
     instance.set_instance_dir(FLAGS_instance_dir + "." + std::to_string(num));
@@ -505,8 +505,8 @@
     instance.set_logcat_port(6700 + num - 1);
     instance.set_config_server_port(6800 + num - 1);
 
-    if (FLAGS_gpu_mode != vsoc::kGpuModeDrmVirgl &&
-        FLAGS_gpu_mode != vsoc::kGpuModeGfxStream) {
+    if (FLAGS_gpu_mode != cuttlefish::kGpuModeDrmVirgl &&
+        FLAGS_gpu_mode != cuttlefish::kGpuModeGfxStream) {
       instance.set_frames_server_port(6900 + num - 1);
     }
 
@@ -559,9 +559,9 @@
   return tmp_config_obj;
 }
 
-bool SaveConfig(const vsoc::CuttlefishConfig& tmp_config_obj) {
+bool SaveConfig(const cuttlefish::CuttlefishConfig& tmp_config_obj) {
   auto config_file = GetConfigFilePath(tmp_config_obj);
-  auto config_link = vsoc::GetGlobalConfigFileLink();
+  auto config_link = cuttlefish::GetGlobalConfigFileLink();
   // Save the config object before starting any host process
   if (!tmp_config_obj.SaveToFile(config_file)) {
     LOG(ERROR) << "Unable to save config object";
@@ -574,7 +574,7 @@
       return false;
     }
   }
-  setenv(vsoc::kCuttlefishConfigEnvVarName, config_file.c_str(), true);
+  setenv(cuttlefish::kCuttlefishConfigEnvVarName, config_file.c_str(), true);
   if (symlink(config_file.c_str(), config_link.c_str()) != 0) {
     LOG(ERROR) << "Failed to create symlink to config file at " << config_link
                << ": " << strerror(errno);
@@ -606,12 +606,12 @@
             return false;
           }
           return (::mkdir(var_empty.c_str(), 0755) == 0);
-        }(vsoc::kCrosvmVarEmptyDir);
+        }(cuttlefish::kCrosvmVarEmptyDir);
   }
 
   // Sepolicy rules need to be updated to support gpu mode. Temporarily disable
   // auto-enabling sandbox when gpu is enabled (b/152323505).
-  if (FLAGS_gpu_mode != vsoc::kGpuModeGuestSwiftshader) {
+  if (FLAGS_gpu_mode != cuttlefish::kGpuModeGuestSwiftshader) {
     default_enable_sandbox = false;
   }
 
@@ -665,7 +665,7 @@
     return false;
   }
   // Set the env variable to empty (in case the caller passed a value for it).
-  unsetenv(vsoc::kCuttlefishConfigEnvVarName);
+  unsetenv(cuttlefish::kCuttlefishConfigEnvVarName);
 
   return ResolveInstanceFiles();
 }
@@ -758,14 +758,14 @@
   return true;
 }
 
-bool CleanPriorFiles(const vsoc::CuttlefishConfig& config, const std::set<std::string>& preserving) {
+bool CleanPriorFiles(const cuttlefish::CuttlefishConfig& config, const std::set<std::string>& preserving) {
   std::vector<std::string> paths = {
     // Everything in the assembly directory
     FLAGS_assembly_dir,
     // The environment file
     GetCuttlefishEnvPath(),
     // The global link to the config file
-    vsoc::GetGlobalConfigFileLink(),
+    cuttlefish::GetGlobalConfigFileLink(),
   };
   for (const auto& instance : config.Instances()) {
     paths.push_back(instance.instance_dir());
@@ -775,7 +775,7 @@
 }
 
 bool DecompressKernel(const std::string& src, const std::string& dst) {
-  cuttlefish::Command decomp_cmd(vsoc::DefaultHostArtifactsPath("bin/extract-vmlinux"));
+  cuttlefish::Command decomp_cmd(cuttlefish::DefaultHostArtifactsPath("bin/extract-vmlinux"));
   decomp_cmd.AddParameter(src);
   auto output_file = cuttlefish::SharedFD::Creat(dst.c_str(), 0666);
   if (!output_file->IsOpen()) {
@@ -788,9 +788,9 @@
   return decomp_proc.Started() && decomp_proc.Wait() == 0;
 }
 
-void ValidateAdbModeFlag(const vsoc::CuttlefishConfig& config) {
+void ValidateAdbModeFlag(const cuttlefish::CuttlefishConfig& config) {
   auto adb_modes = config.adb_mode();
-  adb_modes.erase(vsoc::AdbMode::Unknown);
+  adb_modes.erase(cuttlefish::AdbMode::Unknown);
   if (adb_modes.size() < 1) {
     LOG(INFO) << "ADB not enabled";
   }
@@ -876,7 +876,7 @@
   return ret;
 }
 
-bool ShouldCreateCompositeDisk(const vsoc::CuttlefishConfig& config) {
+bool ShouldCreateCompositeDisk(const cuttlefish::CuttlefishConfig& config) {
   if (!cuttlefish::FileExists(config.composite_disk_path())) {
     return true;
   }
@@ -910,7 +910,7 @@
   return vfs.f_bsize * vfs.f_bavail; // block size * free blocks for unprivileged users
 }
 
-bool CreateCompositeDisk(const vsoc::CuttlefishConfig& config) {
+bool CreateCompositeDisk(const cuttlefish::CuttlefishConfig& config) {
   if (!cuttlefish::SharedFD::Open(config.composite_disk_path().c_str(), O_WRONLY | O_CREAT, 0644)->IsOpen()) {
     LOG(ERROR) << "Could not ensure " << config.composite_disk_path() << " exists";
     return false;
@@ -954,7 +954,7 @@
 # define O_TMPFILE (020000000 | O_DIRECTORY)
 #endif
 
-const vsoc::CuttlefishConfig* InitFilesystemAndCreateConfig(
+const cuttlefish::CuttlefishConfig* InitFilesystemAndCreateConfig(
     int* argc, char*** argv, cuttlefish::FetcherConfig fetcher_config) {
   if (!ParseCommandLineFlags(argc, argv)) {
     LOG(ERROR) << "Failed to parse command arguments";
@@ -1047,7 +1047,7 @@
           exit(AssemblerExitCodes::kInstanceDirCreationError);
         }
       }
-      auto internal_dir = instance.instance_dir() + "/" + vsoc::kInternalDirName;
+      auto internal_dir = instance.instance_dir() + "/" + cuttlefish::kInternalDirName;
       if (!cuttlefish::DirectoryExists(internal_dir)) {
         if (mkdir(internal_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0
            && errno != EEXIST) {
@@ -1069,7 +1069,7 @@
     }
   }
 
-  std::string first_instance = FLAGS_instance_dir + "." + std::to_string(vsoc::GetInstance());
+  std::string first_instance = FLAGS_instance_dir + "." + std::to_string(cuttlefish::GetInstance());
   if (symlink(first_instance.c_str(), FLAGS_instance_dir.c_str()) < 0) {
     LOG(ERROR) << "Could not symlink \"" << first_instance << "\" to \"" << FLAGS_instance_dir << "\"";
     exit(cuttlefish::kCuttlefishConfigurationInitError);
@@ -1086,7 +1086,7 @@
   }
 
   // Do this early so that the config object is ready for anything that needs it
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   if (!config) {
     LOG(ERROR) << "Failed to obtain config singleton";
     exit(AssemblerExitCodes::kCuttlefishConfigurationInitError);
@@ -1232,6 +1232,6 @@
   return config;
 }
 
-std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config) {
+std::string GetConfigFilePath(const cuttlefish::CuttlefishConfig& config) {
   return config.AssemblyPath("cuttlefish_config.json");
 }
diff --git a/host/commands/assemble_cvd/flags.h b/host/commands/assemble_cvd/flags.h
index da5c5b5..e7e33a7 100644
--- a/host/commands/assemble_cvd/flags.h
+++ b/host/commands/assemble_cvd/flags.h
@@ -3,6 +3,6 @@
 #include "host/libs/config/cuttlefish_config.h"
 #include "host/libs/config/fetcher_config.h"
 
-const vsoc::CuttlefishConfig* InitFilesystemAndCreateConfig(
+const cuttlefish::CuttlefishConfig* InitFilesystemAndCreateConfig(
     int* argc, char*** argv, cuttlefish::FetcherConfig config);
-std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config);
+std::string GetConfigFilePath(const cuttlefish::CuttlefishConfig& config);
diff --git a/host/commands/assemble_cvd/super_image_mixer.cc b/host/commands/assemble_cvd/super_image_mixer.cc
index b2ce8d8..c626612 100644
--- a/host/commands/assemble_cvd/super_image_mixer.cc
+++ b/host/commands/assemble_cvd/super_image_mixer.cc
@@ -37,7 +37,7 @@
 namespace {
 
 using cuttlefish::FileExists;
-using vsoc::DefaultHostArtifactsPath;
+using cuttlefish::DefaultHostArtifactsPath;
 
 std::string TargetFilesZip(const cuttlefish::FetcherConfig& fetcher_config,
                            cuttlefish::FileSource source) {
@@ -285,7 +285,7 @@
 } // namespace
 
 bool SuperImageNeedsRebuilding(const cuttlefish::FetcherConfig& fetcher_config,
-                               const vsoc::CuttlefishConfig&) {
+                               const cuttlefish::CuttlefishConfig&) {
   bool has_default_build = false;
   bool has_system_build = false;
   for (const auto& file_iter : fetcher_config.get_cvd_files()) {
@@ -299,7 +299,7 @@
 }
 
 bool RebuildSuperImage(const cuttlefish::FetcherConfig& fetcher_config,
-                       const vsoc::CuttlefishConfig& config,
+                       const cuttlefish::CuttlefishConfig& config,
                        const std::string& output_path) {
   std::string default_target_zip =
       TargetFilesZip(fetcher_config, cuttlefish::FileSource::DEFAULT_BUILD);
diff --git a/host/commands/assemble_cvd/super_image_mixer.h b/host/commands/assemble_cvd/super_image_mixer.h
index c612fd5..8360ee4 100644
--- a/host/commands/assemble_cvd/super_image_mixer.h
+++ b/host/commands/assemble_cvd/super_image_mixer.h
@@ -17,7 +17,7 @@
 #include "host/libs/config/fetcher_config.h"
 
 bool SuperImageNeedsRebuilding(const cuttlefish::FetcherConfig& fetcher_config,
-                               const vsoc::CuttlefishConfig& config);
+                               const cuttlefish::CuttlefishConfig& config);
 bool RebuildSuperImage(const cuttlefish::FetcherConfig& fetcher_config,
-                       const vsoc::CuttlefishConfig& config,
+                       const cuttlefish::CuttlefishConfig& config,
                        const std::string& output_path);
diff --git a/host/commands/console_forwarder/main.cpp b/host/commands/console_forwarder/main.cpp
index 3ec9d36..468dfd8 100644
--- a/host/commands/console_forwarder/main.cpp
+++ b/host/commands/console_forwarder/main.cpp
@@ -196,7 +196,7 @@
     return -2;
   }
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   if (!config) {
     LOG(ERROR) << "Unable to get config object";
     return -3;
diff --git a/host/commands/cvd_status/cvd_status.cc b/host/commands/cvd_status/cvd_status.cc
index 9a90882..ff6b7a3 100644
--- a/host/commands/cvd_status/cvd_status.cc
+++ b/host/commands/cvd_status/cvd_status.cc
@@ -53,7 +53,7 @@
   ::android::base::InitLogging(argv, android::base::StderrLogger);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   if (!config) {
     LOG(ERROR) << "Failed to obtain config object";
     return 1;
diff --git a/host/commands/kernel_log_monitor/kernel_log_server.cc b/host/commands/kernel_log_monitor/kernel_log_server.cc
index 1f4f331..936986f 100644
--- a/host/commands/kernel_log_monitor/kernel_log_server.cc
+++ b/host/commands/kernel_log_monitor/kernel_log_server.cc
@@ -33,12 +33,12 @@
 };
 
 static const std::map<std::string, monitor::BootEvent> kStageToEventMap = {
-    {vsoc::kBootStartedMessage, monitor::BootEvent::BootStarted},
-    {vsoc::kBootCompletedMessage, monitor::BootEvent::BootCompleted},
-    {vsoc::kBootFailedMessage, monitor::BootEvent::BootFailed},
-    {vsoc::kMobileNetworkConnectedMessage,
+    {cuttlefish::kBootStartedMessage, monitor::BootEvent::BootStarted},
+    {cuttlefish::kBootCompletedMessage, monitor::BootEvent::BootCompleted},
+    {cuttlefish::kBootFailedMessage, monitor::BootEvent::BootFailed},
+    {cuttlefish::kMobileNetworkConnectedMessage,
      monitor::BootEvent::MobileNetworkConnected},
-    {vsoc::kWifiConnectedMessage, monitor::BootEvent::WifiNetworkConnected},
+    {cuttlefish::kWifiConnectedMessage, monitor::BootEvent::WifiNetworkConnected},
     // TODO(b/131864854): Replace this with a string less likely to change
     {"init: starting service 'adbd'", monitor::BootEvent::AdbdStarted},
 };
diff --git a/host/commands/kernel_log_monitor/main.cc b/host/commands/kernel_log_monitor/main.cc
index 4c4a7ba..9c65b1b 100644
--- a/host/commands/kernel_log_monitor/main.cc
+++ b/host/commands/kernel_log_monitor/main.cc
@@ -64,7 +64,7 @@
   cuttlefish::DefaultSubprocessLogging(argv);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
 
   CHECK(config) << "Could not open cuttlefish config";
 
diff --git a/host/commands/launch/launch_cvd.cc b/host/commands/launch/launch_cvd.cc
index 1a077b4..1833bb9 100644
--- a/host/commands/launch/launch_cvd.cc
+++ b/host/commands/launch/launch_cvd.cc
@@ -45,7 +45,7 @@
 DEFINE_string(report_anonymous_usage_stats, "", "Report anonymous usage "
             "statistics for metrics collection and analysis.");
 DEFINE_int32(base_instance_num,
-             vsoc::GetInstance(),
+             cuttlefish::GetInstance(),
              "The instance number of the device created. When `-num_instances N`"
              " is used, N instance numbers are claimed starting at this number.");
 DEFINE_string(verbosity, "INFO", "Console logging verbosity. Options are VERBOSE,"
@@ -53,8 +53,8 @@
 
 namespace {
 
-std::string kAssemblerBin = vsoc::DefaultHostArtifactsPath("bin/assemble_cvd");
-std::string kRunnerBin = vsoc::DefaultHostArtifactsPath("bin/run_cvd");
+std::string kAssemblerBin = cuttlefish::DefaultHostArtifactsPath("bin/assemble_cvd");
+std::string kRunnerBin = cuttlefish::DefaultHostArtifactsPath("bin/run_cvd");
 
 cuttlefish::Subprocess StartAssembler(cuttlefish::SharedFD assembler_stdin,
                                cuttlefish::SharedFD assembler_stdout,
@@ -95,12 +95,12 @@
 
 std::string ValidateMetricsConfirmation(std::string use_metrics) {
   if (use_metrics == "") {
-    if (vsoc::CuttlefishConfig::ConfigExists()) {
-      auto config = vsoc::CuttlefishConfig::Get();
+    if (cuttlefish::CuttlefishConfig::ConfigExists()) {
+      auto config = cuttlefish::CuttlefishConfig::Get();
       if (config) {
-        if (config->enable_metrics() == vsoc::CuttlefishConfig::kYes) {
+        if (config->enable_metrics() == cuttlefish::CuttlefishConfig::kYes) {
           use_metrics = "y";
-        } else if (config->enable_metrics() == vsoc::CuttlefishConfig::kNo) {
+        } else if (config->enable_metrics() == cuttlefish::CuttlefishConfig::kNo) {
           use_metrics = "n";
         }
       }
diff --git a/host/commands/log_tee/log_tee.cpp b/host/commands/log_tee/log_tee.cpp
index 783329c..1cf502e 100644
--- a/host/commands/log_tee/log_tee.cpp
+++ b/host/commands/log_tee/log_tee.cpp
@@ -30,7 +30,7 @@
 
   CHECK(FLAGS_log_fd_in >= 0) << "-log_fd_in is required";
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
 
   CHECK(config) << "Could not open cuttlefish config";
 
diff --git a/host/commands/logcat_receiver/main.cpp b/host/commands/logcat_receiver/main.cpp
index 189e0a0..529ea74 100644
--- a/host/commands/logcat_receiver/main.cpp
+++ b/host/commands/logcat_receiver/main.cpp
@@ -29,7 +29,7 @@
   cuttlefish::DefaultSubprocessLogging(argv);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
 
   auto instance = config->ForDefaultInstance();
   auto path = instance.logcat_path();
diff --git a/host/commands/metrics/metrics.cc b/host/commands/metrics/metrics.cc
index 3ddeb11..378155c 100644
--- a/host/commands/metrics/metrics.cc
+++ b/host/commands/metrics/metrics.cc
@@ -27,7 +27,7 @@
   ::android::base::InitLogging(argv, android::base::StderrLogger);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
 
   CHECK(config) << "Could not open cuttlefish config";
 
@@ -43,7 +43,7 @@
             {metrics_log_path, instance.launcher_log_path()}));
   }
 
-  if (config->enable_metrics() != vsoc::CuttlefishConfig::kYes) {
+  if (config->enable_metrics() != cuttlefish::CuttlefishConfig::kYes) {
     LOG(ERROR) << "metrics not enabled, but metrics were launched.";
     return cuttlefish::MetricsExitCodes::kInvalidHostConfiguration;
   }
diff --git a/host/commands/run_cvd/launch.cc b/host/commands/run_cvd/launch.cc
index fbe8aa5..ef3a633 100644
--- a/host/commands/run_cvd/launch.cc
+++ b/host/commands/run_cvd/launch.cc
@@ -18,46 +18,46 @@
 
 namespace {
 
-std::string GetAdbConnectorTcpArg(const vsoc::CuttlefishConfig& config) {
+std::string GetAdbConnectorTcpArg(const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   return std::string{"127.0.0.1:"} + std::to_string(instance.host_port());
 }
 
-std::string GetAdbConnectorVsockArg(const vsoc::CuttlefishConfig& config) {
+std::string GetAdbConnectorVsockArg(const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   return std::string{"vsock:"} + std::to_string(instance.vsock_guest_cid()) +
          std::string{":5555"};
 }
 
-bool AdbModeEnabled(const vsoc::CuttlefishConfig& config, vsoc::AdbMode mode) {
+bool AdbModeEnabled(const cuttlefish::CuttlefishConfig& config, cuttlefish::AdbMode mode) {
   return config.adb_mode().count(mode) > 0;
 }
 
-bool AdbVsockTunnelEnabled(const vsoc::CuttlefishConfig& config) {
+bool AdbVsockTunnelEnabled(const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   return instance.vsock_guest_cid() > 2 &&
-         AdbModeEnabled(config, vsoc::AdbMode::VsockTunnel);
+         AdbModeEnabled(config, cuttlefish::AdbMode::VsockTunnel);
 }
 
-bool AdbVsockHalfTunnelEnabled(const vsoc::CuttlefishConfig& config) {
+bool AdbVsockHalfTunnelEnabled(const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   return instance.vsock_guest_cid() > 2 &&
-         AdbModeEnabled(config, vsoc::AdbMode::VsockHalfTunnel);
+         AdbModeEnabled(config, cuttlefish::AdbMode::VsockHalfTunnel);
 }
 
-bool AdbTcpConnectorEnabled(const vsoc::CuttlefishConfig& config) {
+bool AdbTcpConnectorEnabled(const cuttlefish::CuttlefishConfig& config) {
   bool vsock_tunnel = AdbVsockTunnelEnabled(config);
   bool vsock_half_tunnel = AdbVsockHalfTunnelEnabled(config);
   return config.run_adb_connector() && (vsock_tunnel || vsock_half_tunnel);
 }
 
-bool AdbVsockConnectorEnabled(const vsoc::CuttlefishConfig& config) {
+bool AdbVsockConnectorEnabled(const cuttlefish::CuttlefishConfig& config) {
   return config.run_adb_connector() &&
-         AdbModeEnabled(config, vsoc::AdbMode::NativeVsock);
+         AdbModeEnabled(config, cuttlefish::AdbMode::NativeVsock);
 }
 
 cuttlefish::OnSocketReadyCb GetOnSubprocessExitCallback(
-    const vsoc::CuttlefishConfig& config) {
+    const cuttlefish::CuttlefishConfig& config) {
   if (config.restart_subprocesses()) {
     return cuttlefish::ProcessMonitor::RestartOnExitCb;
   } else {
@@ -78,7 +78,7 @@
 // Creates the frame and input sockets and add the relevant arguments to the vnc
 // server and webrtc commands
 StreamerLaunchResult CreateStreamerServers(
-    cuttlefish::Command* cmd, const vsoc::CuttlefishConfig& config) {
+    cuttlefish::Command* cmd, const cuttlefish::CuttlefishConfig& config) {
   StreamerLaunchResult server_ret;
   cuttlefish::SharedFD touch_server;
   cuttlefish::SharedFD keyboard_server;
@@ -110,8 +110,8 @@
   cmd->AddParameter("-keyboard_fd=", keyboard_server);
 
   cuttlefish::SharedFD frames_server;
-  if (config.gpu_mode() == vsoc::kGpuModeDrmVirgl ||
-      config.gpu_mode() == vsoc::kGpuModeGfxStream) {
+  if (config.gpu_mode() == cuttlefish::kGpuModeDrmVirgl ||
+      config.gpu_mode() == cuttlefish::kGpuModeGfxStream) {
     frames_server = CreateUnixInputServer(instance.frames_socket_path());
   } else {
     frames_server = cuttlefish::SharedFD::VsockServer(instance.frames_server_port(),
@@ -127,12 +127,12 @@
 
 }  // namespace
 
-bool LogcatReceiverEnabled(const vsoc::CuttlefishConfig& config) {
+bool LogcatReceiverEnabled(const cuttlefish::CuttlefishConfig& config) {
   return config.logcat_mode() == cuttlefish::kLogcatVsockMode;
 }
 
 std::vector<cuttlefish::SharedFD> LaunchKernelLogMonitor(
-    const vsoc::CuttlefishConfig& config, cuttlefish::ProcessMonitor* process_monitor,
+    const cuttlefish::CuttlefishConfig& config, cuttlefish::ProcessMonitor* process_monitor,
     unsigned int number_of_event_pipes) {
   auto instance = config.ForDefaultInstance();
   auto log_name = instance.kernel_log_pipe_name();
@@ -176,7 +176,7 @@
   return ret;
 }
 
-void LaunchLogcatReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
+void LaunchLogcatReceiverIfEnabled(const cuttlefish::CuttlefishConfig& config,
                                    cuttlefish::ProcessMonitor* process_monitor) {
   if (!LogcatReceiverEnabled(config)) {
     return;
@@ -196,7 +196,7 @@
   return;
 }
 
-void LaunchConfigServer(const vsoc::CuttlefishConfig& config,
+void LaunchConfigServer(const cuttlefish::CuttlefishConfig& config,
                         cuttlefish::ProcessMonitor* process_monitor) {
   auto instance = config.ForDefaultInstance();
   auto port = instance.config_server_port();
@@ -213,7 +213,7 @@
   return;
 }
 
-void LaunchTombstoneReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
+void LaunchTombstoneReceiverIfEnabled(const cuttlefish::CuttlefishConfig& config,
                                       cuttlefish::ProcessMonitor* process_monitor) {
   if (!config.enable_tombstone_receiver()) {
     return;
@@ -250,7 +250,7 @@
 }
 
 StreamerLaunchResult LaunchVNCServer(
-    const vsoc::CuttlefishConfig& config, cuttlefish::ProcessMonitor* process_monitor,
+    const cuttlefish::CuttlefishConfig& config, cuttlefish::ProcessMonitor* process_monitor,
     std::function<bool(MonitorEntry*)> callback) {
   auto instance = config.ForDefaultInstance();
   // Launch the vnc server, don't wait for it to complete
@@ -266,7 +266,7 @@
 }
 
 void LaunchAdbConnectorIfEnabled(cuttlefish::ProcessMonitor* process_monitor,
-                                 const vsoc::CuttlefishConfig& config,
+                                 const cuttlefish::CuttlefishConfig& config,
                                  cuttlefish::SharedFD adbd_events_pipe) {
   cuttlefish::Command adb_connector(config.adb_connector_binary());
   adb_connector.AddParameter("-adbd_events_fd=", adbd_events_pipe);
@@ -292,7 +292,7 @@
 }
 
 StreamerLaunchResult LaunchWebRTC(cuttlefish::ProcessMonitor* process_monitor,
-                                  const vsoc::CuttlefishConfig& config) {
+                                  const cuttlefish::CuttlefishConfig& config) {
   if (config.ForDefaultInstance().start_webrtc_sig_server()) {
     cuttlefish::Command sig_server(config.sig_server_binary());
     sig_server.AddParameter("-assets_dir=", config.webrtc_assets_dir());
@@ -331,7 +331,7 @@
 }
 
 void LaunchSocketVsockProxyIfEnabled(cuttlefish::ProcessMonitor* process_monitor,
-                                     const vsoc::CuttlefishConfig& config) {
+                                     const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   if (AdbVsockTunnelEnabled(config)) {
     cuttlefish::Command adb_tunnel(config.socket_vsock_proxy_binary());
@@ -358,12 +358,12 @@
 }
 
 void LaunchTpmSimulator(cuttlefish::ProcessMonitor* process_monitor,
-                   const vsoc::CuttlefishConfig& config) {
+                   const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   auto port = instance.tpm_port();
   auto socket = cuttlefish::SharedFD::VsockServer(port, SOCK_STREAM);
   cuttlefish::Command tpm_command(
-      vsoc::DefaultHostArtifactsPath("bin/tpm_simulator_manager"));
+      cuttlefish::DefaultHostArtifactsPath("bin/tpm_simulator_manager"));
   tpm_command.AddParameter("-port=", port);
   process_monitor->StartSubprocess(std::move(tpm_command),
                                    GetOnSubprocessExitCallback(config));
@@ -377,7 +377,7 @@
 }
 
 void LaunchMetrics(cuttlefish::ProcessMonitor* process_monitor,
-                   const vsoc::CuttlefishConfig& config) {
+                   const cuttlefish::CuttlefishConfig& config) {
   cuttlefish::Command metrics(config.metrics_binary());
 
   process_monitor->StartSubprocess(std::move(metrics),
@@ -385,7 +385,7 @@
 }
 
 void LaunchTpmPassthrough(cuttlefish::ProcessMonitor* process_monitor,
-                          const vsoc::CuttlefishConfig& config) {
+                          const cuttlefish::CuttlefishConfig& config) {
   auto server = cuttlefish::SharedFD::VsockServer(SOCK_STREAM);
   if (!server->IsOpen()) {
     LOG(ERROR) << "Unable to create tpm passthrough server: "
@@ -393,7 +393,7 @@
     std::exit(RunnerExitCodes::kTpmPassthroughError);
   }
   cuttlefish::Command tpm_command(
-      vsoc::DefaultHostArtifactsPath("bin/vtpm_passthrough"));
+      cuttlefish::DefaultHostArtifactsPath("bin/vtpm_passthrough"));
   tpm_command.AddParameter("-server_fd=", server);
   tpm_command.AddParameter("-device=", config.tpm_device());
 
@@ -402,7 +402,7 @@
 }
 
 void LaunchTpm(cuttlefish::ProcessMonitor* process_monitor,
-               const vsoc::CuttlefishConfig& config) {
+               const cuttlefish::CuttlefishConfig& config) {
   if (config.tpm_device() != "") {
     if (config.tpm_binary() != "") {
       LOG(WARNING)
@@ -415,10 +415,10 @@
 }
 
 void LaunchSecureEnvironment(cuttlefish::ProcessMonitor* process_monitor,
-                             const vsoc::CuttlefishConfig& config) {
+                             const cuttlefish::CuttlefishConfig& config) {
   auto port = config.ForDefaultInstance().keymaster_vsock_port();
   auto server = cuttlefish::SharedFD::VsockServer(port, SOCK_STREAM);
-  cuttlefish::Command command(vsoc::DefaultHostArtifactsPath("bin/secure_env"));
+  cuttlefish::Command command(cuttlefish::DefaultHostArtifactsPath("bin/secure_env"));
   command.AddParameter("-keymaster_fd=", server);
   process_monitor->StartSubprocess(std::move(command),
                                    GetOnSubprocessExitCallback(config));
diff --git a/host/commands/run_cvd/launch.h b/host/commands/run_cvd/launch.h
index 42bd5bc..d785c27 100644
--- a/host/commands/run_cvd/launch.h
+++ b/host/commands/run_cvd/launch.h
@@ -10,38 +10,38 @@
 #include "host/libs/config/cuttlefish_config.h"
 
 std::vector <cuttlefish::SharedFD> LaunchKernelLogMonitor(
-    const vsoc::CuttlefishConfig& config,
+    const cuttlefish::CuttlefishConfig& config,
     cuttlefish::ProcessMonitor* process_monitor,
     unsigned int number_of_event_pipes);
 void LaunchAdbConnectorIfEnabled(cuttlefish::ProcessMonitor* process_monitor,
-                                 const vsoc::CuttlefishConfig& config,
+                                 const cuttlefish::CuttlefishConfig& config,
                                  cuttlefish::SharedFD adbd_events_pipe);
 void LaunchSocketVsockProxyIfEnabled(cuttlefish::ProcessMonitor* process_monitor,
-                                 const vsoc::CuttlefishConfig& config);
+                                 const cuttlefish::CuttlefishConfig& config);
 
 struct StreamerLaunchResult {
   bool launched = false;
 };
 StreamerLaunchResult LaunchVNCServer(
-    const vsoc::CuttlefishConfig& config,
+    const cuttlefish::CuttlefishConfig& config,
     cuttlefish::ProcessMonitor* process_monitor,
     std::function<bool(cuttlefish::MonitorEntry*)> callback);
 
-void LaunchTombstoneReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
+void LaunchTombstoneReceiverIfEnabled(const cuttlefish::CuttlefishConfig& config,
                                       cuttlefish::ProcessMonitor* process_monitor);
-void LaunchLogcatReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
+void LaunchLogcatReceiverIfEnabled(const cuttlefish::CuttlefishConfig& config,
                                    cuttlefish::ProcessMonitor* process_monitor);
-void LaunchConfigServer(const vsoc::CuttlefishConfig& config,
+void LaunchConfigServer(const cuttlefish::CuttlefishConfig& config,
                         cuttlefish::ProcessMonitor* process_monitor);
 
 StreamerLaunchResult LaunchWebRTC(cuttlefish::ProcessMonitor* process_monitor,
-                                  const vsoc::CuttlefishConfig& config);
+                                  const cuttlefish::CuttlefishConfig& config);
 
 void LaunchTpm(cuttlefish::ProcessMonitor* process_monitor,
-               const vsoc::CuttlefishConfig& config);
+               const cuttlefish::CuttlefishConfig& config);
 
 void LaunchMetrics(cuttlefish::ProcessMonitor* process_monitor,
-                                  const vsoc::CuttlefishConfig& config);
+                                  const cuttlefish::CuttlefishConfig& config);
 
 void LaunchSecureEnvironment(cuttlefish::ProcessMonitor* process_monitor,
-                             const vsoc::CuttlefishConfig& config);
+                             const cuttlefish::CuttlefishConfig& config);
diff --git a/host/commands/run_cvd/main.cc b/host/commands/run_cvd/main.cc
index 5d350a6..6667f43 100644
--- a/host/commands/run_cvd/main.cc
+++ b/host/commands/run_cvd/main.cc
@@ -58,13 +58,13 @@
 #include "host/libs/vm_manager/vm_manager.h"
 #include "host/libs/vm_manager/qemu_manager.h"
 
-using vsoc::ForCurrentInstance;
+using cuttlefish::ForCurrentInstance;
 using cuttlefish::RunnerExitCodes;
 
 namespace {
 
 cuttlefish::OnSocketReadyCb GetOnSubprocessExitCallback(
-    const vsoc::CuttlefishConfig& config) {
+    const cuttlefish::CuttlefishConfig& config) {
   if (config.restart_subprocesses()) {
     return cuttlefish::ProcessMonitor::RestartOnExitCb;
   } else {
@@ -152,7 +152,7 @@
       });
 }
 
-bool WriteCuttlefishEnvironment(const vsoc::CuttlefishConfig& config) {
+bool WriteCuttlefishEnvironment(const cuttlefish::CuttlefishConfig& config) {
   auto env = cuttlefish::SharedFD::Open(config.cuttlefish_env_path().c_str(),
                                  O_CREAT | O_RDWR, 0755);
   if (!env->IsOpen()) {
@@ -169,7 +169,7 @@
 
 // Forks and returns the write end of a pipe to the child process. The parent
 // process waits for boot events to come through the pipe and exits accordingly.
-cuttlefish::SharedFD DaemonizeLauncher(const vsoc::CuttlefishConfig& config) {
+cuttlefish::SharedFD DaemonizeLauncher(const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   cuttlefish::SharedFD read_end, write_end;
   if (!cuttlefish::SharedFD::Pipe(&read_end, &write_end)) {
@@ -195,9 +195,9 @@
       LOG(ERROR) << "Unexpected exit code: " << exit_code;
     }
     if (exit_code == RunnerExitCodes::kSuccess) {
-      LOG(INFO) << vsoc::kBootCompletedMessage;
+      LOG(INFO) << cuttlefish::kBootCompletedMessage;
     } else {
-      LOG(INFO) << vsoc::kBootFailedMessage;
+      LOG(INFO) << cuttlefish::kBootFailedMessage;
     }
     std::exit(exit_code);
   } else {
@@ -275,7 +275,7 @@
   }
 }
 
-std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config) {
+std::string GetConfigFilePath(const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   return instance.PerInstancePath("cuttlefish_config.json");
 }
@@ -313,14 +313,14 @@
   for (const auto& file : input_files) {
     if (file.find("cuttlefish_config.json") != std::string::npos) {
       found_config = true;
-      setenv(vsoc::kCuttlefishConfigEnvVarName, file.c_str(), /* overwrite */ false);
+      setenv(cuttlefish::kCuttlefishConfigEnvVarName, file.c_str(), /* overwrite */ false);
     }
   }
   if (!found_config) {
     return RunnerExitCodes::kCuttlefishConfigurationInitError;
   }
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   auto instance = config->ForDefaultInstance();
 
   auto log_path = instance.launcher_log_path();
@@ -415,7 +415,7 @@
   // Monitor and restart host processes supporting the CVD
   cuttlefish::ProcessMonitor process_monitor;
 
-  if (config->enable_metrics() == vsoc::CuttlefishConfig::kYes) {
+  if (config->enable_metrics() == cuttlefish::CuttlefishConfig::kYes) {
     LaunchMetrics(&process_monitor, *config);
   }
 
diff --git a/host/commands/run_cvd/pre_launch_initializers.h b/host/commands/run_cvd/pre_launch_initializers.h
index 79f6eed..6ab7788 100644
--- a/host/commands/run_cvd/pre_launch_initializers.h
+++ b/host/commands/run_cvd/pre_launch_initializers.h
@@ -24,11 +24,11 @@
 // machine is started.
 // To add initializers for more regions declare here, implement in its own
 // source file and call from PreLaunchInitializers::Initialize().
-void InitializeScreenRegion(const vsoc::CuttlefishConfig& config);
+void InitializeScreenRegion(const cuttlefish::CuttlefishConfig& config);
 
 class PreLaunchInitializers {
  public:
-  static void Initialize(const vsoc::CuttlefishConfig& config) {
+  static void Initialize(const cuttlefish::CuttlefishConfig& config) {
     InitializeScreenRegion(config);
   }
 };
diff --git a/host/commands/stop_cvd/main.cc b/host/commands/stop_cvd/main.cc
index ad0b524..808eaf4 100644
--- a/host/commands/stop_cvd/main.cc
+++ b/host/commands/stop_cvd/main.cc
@@ -73,13 +73,13 @@
     // Add files in the tombstone directory
     paths.insert(instance_dir + "/tombstones/*");
     // Add files in the internal directory
-    paths.insert(instance_dir + "/" + std::string(vsoc::kInternalDirName) + "/*");
+    paths.insert(instance_dir + "/" + std::string(cuttlefish::kInternalDirName) + "/*");
   }
   return paths;
 }
 
-std::set<std::string> PathsForInstance(const vsoc::CuttlefishConfig& config,
-                                       const vsoc::CuttlefishConfig::InstanceSpecific instance) {
+std::set<std::string> PathsForInstance(const cuttlefish::CuttlefishConfig& config,
+                                       const cuttlefish::CuttlefishConfig::InstanceSpecific instance) {
   return {
     config.assembly_dir(),
     config.assembly_dir() + "/*",
@@ -138,7 +138,7 @@
   return exit_code;
 }
 
-bool CleanStopInstance(const vsoc::CuttlefishConfig::InstanceSpecific& instance) {
+bool CleanStopInstance(const cuttlefish::CuttlefishConfig::InstanceSpecific& instance) {
   auto monitor_path = instance.launcher_monitor_socket_path();
   if (monitor_path.empty()) {
     LOG(ERROR) << "No path to launcher monitor found";
@@ -189,8 +189,8 @@
   return true;
 }
 
-int StopInstance(const vsoc::CuttlefishConfig& config,
-                 const vsoc::CuttlefishConfig::InstanceSpecific& instance) {
+int StopInstance(const cuttlefish::CuttlefishConfig& config,
+                 const cuttlefish::CuttlefishConfig::InstanceSpecific& instance) {
   bool res = CleanStopInstance(instance);
   if (!res) {
     return FallBackStop(PathsForInstance(config, instance));
@@ -204,7 +204,7 @@
   ::android::base::InitLogging(argv, android::base::StderrLogger);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   if (!config) {
     LOG(ERROR) << "Failed to obtain config object";
     return FallBackStop(FallbackPaths());
diff --git a/host/commands/tpm_simulator_manager/tpm_simulator_manager.cpp b/host/commands/tpm_simulator_manager/tpm_simulator_manager.cpp
index 238b092..957586b 100644
--- a/host/commands/tpm_simulator_manager/tpm_simulator_manager.cpp
+++ b/host/commands/tpm_simulator_manager/tpm_simulator_manager.cpp
@@ -47,7 +47,7 @@
   google::ParseCommandLineFlags(&argc, &argv, true);
 
   CHECK(FLAGS_port > 0) << "A port must be set";
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   CHECK(config) << "Unable to get config object";
 
   // Assumes linked on the host with glibc
diff --git a/host/frontend/gcastv2/libsource/AudioSource.cpp b/host/frontend/gcastv2/libsource/AudioSource.cpp
index 101d4fc..17722a9 100644
--- a/host/frontend/gcastv2/libsource/AudioSource.cpp
+++ b/host/frontend/gcastv2/libsource/AudioSource.cpp
@@ -771,7 +771,7 @@
                         uint8_t buffer[4096];
 
                         struct timespec absTimeLimit;
-                        vsoc::RegionView::GetFutureTime(
+                        cuttlefish::RegionView::GetFutureTime(
                                 1000000000ll ns_from_now, &absTimeLimit);
 
                         intptr_t res = mRegionView->data()->audio_queue.Read(
diff --git a/host/frontend/gcastv2/libsource/include/source/AudioSource.h b/host/frontend/gcastv2/libsource/include/source/AudioSource.h
index 7c7771e..bd2e4b1 100644
--- a/host/frontend/gcastv2/libsource/include/source/AudioSource.h
+++ b/host/frontend/gcastv2/libsource/include/source/AudioSource.h
@@ -23,7 +23,7 @@
 
 #define SIMULATE_AUDIO          0
 
-namespace vsoc {
+namespace cuttlefish {
     class RegionWorker;
     namespace audio_data {
         class AudioDataRegionView;
@@ -33,7 +33,7 @@
 namespace android {
 
 struct AudioSource : public StreamingSource {
-    using AudioDataRegionView = vsoc::audio_data::AudioDataRegionView;
+    using AudioDataRegionView = cuttlefish::audio_data::AudioDataRegionView;
 
     enum class Format {
         OPUS,
diff --git a/host/frontend/gcastv2/webrtc/ServerState.cpp b/host/frontend/gcastv2/webrtc/ServerState.cpp
index 82ed684..bd09364 100644
--- a/host/frontend/gcastv2/webrtc/ServerState.cpp
+++ b/host/frontend/gcastv2/webrtc/ServerState.cpp
@@ -38,7 +38,7 @@
       mRunLoop(runLoop),
       mVideoFormat(videoFormat) {
 
-    auto config = vsoc::CuttlefishConfig::Get();
+    auto config = cuttlefish::CuttlefishConfig::Get();
 
     android::FrameBufferSource::Format fbSourceFormat;
     switch (videoFormat) {
diff --git a/host/frontend/gcastv2/webrtc/client_handler.cpp b/host/frontend/gcastv2/webrtc/client_handler.cpp
index 9eff97c..96f2f4b 100644
--- a/host/frontend/gcastv2/webrtc/client_handler.cpp
+++ b/host/frontend/gcastv2/webrtc/client_handler.cpp
@@ -73,7 +73,7 @@
 
 std::shared_ptr<AdbHandler> ClientHandler::adb_handler() {
   if (!adb_handler_) {
-    auto config = vsoc::CuttlefishConfig::Get();
+    auto config = cuttlefish::CuttlefishConfig::Get();
     adb_handler_.reset(
         new AdbHandler(mRunLoop, config->ForDefaultInstance().adb_ip_and_port(),
                        [this](const uint8_t *msg, size_t length) {
diff --git a/host/frontend/gcastv2/webrtc/sig_server_handler.cpp b/host/frontend/gcastv2/webrtc/sig_server_handler.cpp
index 9b2b6c4..60a0a79 100644
--- a/host/frontend/gcastv2/webrtc/sig_server_handler.cpp
+++ b/host/frontend/gcastv2/webrtc/sig_server_handler.cpp
@@ -170,7 +170,7 @@
 }
 
 void SigServerHandler::OnOpen() {
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   Json::Value register_obj;
   register_obj[cuttlefish::webrtc_signaling::kTypeField] =
       cuttlefish::webrtc_signaling::kRegisterType;
diff --git a/host/frontend/gcastv2/webrtc/webRTC.cpp b/host/frontend/gcastv2/webrtc/webRTC.cpp
index d189f30..c0ad5f0 100644
--- a/host/frontend/gcastv2/webrtc/webRTC.cpp
+++ b/host/frontend/gcastv2/webrtc/webRTC.cpp
@@ -59,7 +59,7 @@
   SSLSocket::Init();
   DTLS::Init();
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
 
   auto sig_server_addr = config->sig_server_address();
   auto sig_server_port = config->sig_server_port();
diff --git a/host/frontend/vnc_server/vnc_client_connection.cpp b/host/frontend/vnc_server/vnc_client_connection.cpp
index 7e9b6df..e414600 100644
--- a/host/frontend/vnc_server/vnc_client_connection.cpp
+++ b/host/frontend/vnc_server/vnc_client_connection.cpp
@@ -88,7 +88,7 @@
 constexpr size_t kClientCutTextLength = 7;  // more bytes follow
 
 std::string HostName() {
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   auto instance = config->ForDefaultInstance();
   return !config || instance.device_title().empty() ? std::string{"localhost"}
                                                     : instance.device_title();
diff --git a/host/libs/config/cuttlefish_config.cpp b/host/libs/config/cuttlefish_config.cpp
index 2948acd..6619be0 100644
--- a/host/libs/config/cuttlefish_config.cpp
+++ b/host/libs/config/cuttlefish_config.cpp
@@ -47,13 +47,13 @@
     // Try to get it from the user instead
     instance_str = std::getenv("USER");
 
-    if (!instance_str || std::strncmp(instance_str, vsoc::kVsocUserPrefix,
-                                      sizeof(vsoc::kVsocUserPrefix) - 1)) {
+    if (!instance_str || std::strncmp(instance_str, cuttlefish::kVsocUserPrefix,
+                                      sizeof(cuttlefish::kVsocUserPrefix) - 1)) {
       // No user or we don't recognize this user
       LOG(DEBUG) << "No user or non-vsoc user, returning default config";
       return kDefaultInstance;
     }
-    instance_str += sizeof(vsoc::kVsocUserPrefix) - 1;
+    instance_str += sizeof(cuttlefish::kVsocUserPrefix) - 1;
 
     // Set the environment variable so that child processes see it
     setenv(kInstanceEnvironmentVariable, instance_str, 0);
@@ -185,7 +185,7 @@
 const char* kWifiMacAddress = "wifi_mac_address";
 }  // namespace
 
-namespace vsoc {
+namespace cuttlefish {
 
 const char* const kGpuModeGuestSwiftshader = "guest_swiftshader";
 const char* const kGpuModeDrmVirgl = "drm_virgl";
@@ -1073,7 +1073,7 @@
 // Returns nullptr if there was an error loading from file
 /*static*/ CuttlefishConfig* CuttlefishConfig::BuildConfigImpl() {
   auto config_file_path = cuttlefish::StringFromEnv(kCuttlefishConfigEnvVarName,
-                                             vsoc::GetGlobalConfigFileLink());
+                                             cuttlefish::GetGlobalConfigFileLink());
   auto ret = new CuttlefishConfig();
   if (ret) {
     auto loaded = ret->LoadFromFile(config_file_path.c_str());
@@ -1092,7 +1092,7 @@
 
 /*static*/ bool CuttlefishConfig::ConfigExists() {
   auto config_file_path = cuttlefish::StringFromEnv(kCuttlefishConfigEnvVarName,
-                                             vsoc::GetGlobalConfigFileLink());
+                                             cuttlefish::GetGlobalConfigFileLink());
   auto real_file_path = cuttlefish::AbsolutePath(config_file_path.c_str());
   return cuttlefish::FileExists(real_file_path);
 }
@@ -1197,7 +1197,7 @@
 
 int GetDefaultPerInstanceVsockCid() {
   constexpr int kFirstGuestCid = 3;
-  return vsoc::HostSupportsVsock() ? ForCurrentInstance(kFirstGuestCid) : 0;
+  return cuttlefish::HostSupportsVsock() ? ForCurrentInstance(kFirstGuestCid) : 0;
 }
 
 std::string DefaultHostArtifactsPath(const std::string& file_name) {
@@ -1226,4 +1226,4 @@
           "/usr/lib/cuttlefish-common/bin/capability_query.py vsock") == 0;
   return supported;
 }
-}  // namespace vsoc
+}  // namespace cuttlefish
diff --git a/host/libs/config/cuttlefish_config.h b/host/libs/config/cuttlefish_config.h
index 244a917..2bce548 100644
--- a/host/libs/config/cuttlefish_config.h
+++ b/host/libs/config/cuttlefish_config.h
@@ -30,7 +30,7 @@
 constexpr char kLogcatVsockMode[] = "vsock";
 }
 
-namespace vsoc {
+namespace cuttlefish {
 
 constexpr char kDefaultUuidPrefix[] = "699acfc4-c8c4-11e7-882b-5065f31dc1";
 constexpr char kCuttlefishConfigEnvVarName[] = "CUTTLEFISH_CONFIG_FILE";
@@ -494,4 +494,4 @@
 extern const char* const kGpuModeGuestSwiftshader;
 extern const char* const kGpuModeDrmVirgl;
 extern const char* const kGpuModeGfxStream;
-}  // namespace vsoc
+}  // namespace cuttlefish
diff --git a/host/libs/config/kernel_args.cpp b/host/libs/config/kernel_args.cpp
index f640c36..9331702 100644
--- a/host/libs/config/kernel_args.cpp
+++ b/host/libs/config/kernel_args.cpp
@@ -45,7 +45,7 @@
   return stream.str();
 }
 
-std::vector<std::string> KernelCommandLineFromConfig(const vsoc::CuttlefishConfig& config) {
+std::vector<std::string> KernelCommandLineFromConfig(const cuttlefish::CuttlefishConfig& config) {
   auto instance = config.ForDefaultInstance();
   std::vector<std::string> kernel_cmdline;
 
diff --git a/host/libs/config/kernel_args.h b/host/libs/config/kernel_args.h
index 9a0feb7..5d4b396 100644
--- a/host/libs/config/kernel_args.h
+++ b/host/libs/config/kernel_args.h
@@ -21,4 +21,4 @@
 
 #include "host/libs/config/cuttlefish_config.h"
 
-std::vector<std::string> KernelCommandLineFromConfig(const vsoc::CuttlefishConfig& config);
+std::vector<std::string> KernelCommandLineFromConfig(const cuttlefish::CuttlefishConfig& config);
diff --git a/host/libs/config/logging.cpp b/host/libs/config/logging.cpp
index c56a31c..95085d6 100644
--- a/host/libs/config/logging.cpp
+++ b/host/libs/config/logging.cpp
@@ -27,7 +27,7 @@
 void DefaultSubprocessLogging(char* argv[]) {
   ::android::base::InitLogging(argv, android::base::StderrLogger);
 
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
 
   CHECK(config) << "Could not open cuttlefish config";
 
diff --git a/host/libs/screen_connector/screen_connector.cpp b/host/libs/screen_connector/screen_connector.cpp
index f5eae7e..91bd0c4 100644
--- a/host/libs/screen_connector/screen_connector.cpp
+++ b/host/libs/screen_connector/screen_connector.cpp
@@ -25,11 +25,11 @@
 namespace cuttlefish {
 
 ScreenConnector* ScreenConnector::Get(int frames_fd) {
-  auto config = vsoc::CuttlefishConfig::Get();
-  if (config->gpu_mode() == vsoc::kGpuModeDrmVirgl ||
-      config->gpu_mode() == vsoc::kGpuModeGfxStream) {
+  auto config = cuttlefish::CuttlefishConfig::Get();
+  if (config->gpu_mode() == cuttlefish::kGpuModeDrmVirgl ||
+      config->gpu_mode() == cuttlefish::kGpuModeGfxStream) {
     return new WaylandScreenConnector(frames_fd);
-  } else if (config->gpu_mode() == vsoc::kGpuModeGuestSwiftshader) {
+  } else if (config->gpu_mode() == cuttlefish::kGpuModeGuestSwiftshader) {
     return new SocketBasedScreenConnector(frames_fd);
   } else {
       LOG(ERROR) << "Invalid gpu mode: " << config->gpu_mode();
diff --git a/host/libs/screen_connector/screen_connector.h b/host/libs/screen_connector/screen_connector.h
index 5e0f5cd..68df5eb 100644
--- a/host/libs/screen_connector/screen_connector.h
+++ b/host/libs/screen_connector/screen_connector.h
@@ -43,11 +43,11 @@
   }
 
   static inline int ScreenHeight() {
-      return vsoc::CuttlefishConfig::Get()->y_res();
+      return cuttlefish::CuttlefishConfig::Get()->y_res();
   }
 
   static inline int ScreenWidth() {
-      return vsoc::CuttlefishConfig::Get()->x_res();
+      return cuttlefish::CuttlefishConfig::Get()->x_res();
   }
 
   static inline int ScreenStride() {
diff --git a/host/libs/vm_manager/crosvm_manager.cpp b/host/libs/vm_manager/crosvm_manager.cpp
index da7679a..08910f6 100644
--- a/host/libs/vm_manager/crosvm_manager.cpp
+++ b/host/libs/vm_manager/crosvm_manager.cpp
@@ -37,7 +37,7 @@
 
 namespace {
 
-std::string GetControlSocketPath(const vsoc::CuttlefishConfig* config) {
+std::string GetControlSocketPath(const cuttlefish::CuttlefishConfig* config) {
   return config->ForDefaultInstance()
       .PerInstanceInternalPath("crosvm_control.sock");
 }
@@ -63,7 +63,7 @@
   bool success = true;
   auto dhcp_leases = cuttlefish::ParseDnsmasqLeases(lease_file_fd);
   for (auto& lease : dhcp_leases) {
-    std::uint8_t dhcp_server_ip[] = {192, 168, 96, (std::uint8_t) (vsoc::ForCurrentInstance(1) * 4 - 3)};
+    std::uint8_t dhcp_server_ip[] = {192, 168, 96, (std::uint8_t) (cuttlefish::ForCurrentInstance(1) * 4 - 3)};
     if (!cuttlefish::ReleaseDhcp4(tap_fd, lease.mac_address, lease.ip_address, dhcp_server_ip)) {
       LOG(ERROR) << "Failed to release " << lease;
       success = false;
@@ -75,7 +75,7 @@
 }
 
 bool Stop() {
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   cuttlefish::Command command(config->crosvm_binary());
   command.AddParameter("stop");
   command.AddParameter(GetControlSocketPath(config));
@@ -94,7 +94,7 @@
   // the HAL search path allows for fallbacks, and fallbacks in conjunction
   // with properities lead to non-deterministic behavior while loading the
   // HALs.
-  if (gpu_mode == vsoc::kGpuModeGuestSwiftshader) {
+  if (gpu_mode == cuttlefish::kGpuModeGuestSwiftshader) {
     return {
         "androidboot.hardware.gralloc=cutf_ashmem",
         "androidboot.hardware.hwcomposer=cutf_hwc2",
@@ -111,14 +111,14 @@
   modprobe_cmd.AddParameter("--modeset");
   modprobe_cmd.Start().Wait();
 
-  if (gpu_mode == vsoc::kGpuModeDrmVirgl) {
+  if (gpu_mode == cuttlefish::kGpuModeDrmVirgl) {
     return {
       "androidboot.hardware.gralloc=minigbm",
       "androidboot.hardware.hwcomposer=drm_minigbm",
       "androidboot.hardware.egl=mesa",
     };
   }
-  if (gpu_mode == vsoc::kGpuModeGfxStream) {
+  if (gpu_mode == cuttlefish::kGpuModeGfxStream) {
     return {
         "androidboot.hardware.gralloc=minigbm",
         "androidboot.hardware.hwcomposer=drm_minigbm",
@@ -140,7 +140,7 @@
   }
 }
 
-CrosvmManager::CrosvmManager(const vsoc::CuttlefishConfig* config)
+CrosvmManager::CrosvmManager(const cuttlefish::CuttlefishConfig* config)
     : VmManager(config) {}
 
 std::vector<cuttlefish::Command> CrosvmManager::StartCommands() {
@@ -157,9 +157,9 @@
 
   auto gpu_mode = config_->gpu_mode();
 
-  if (gpu_mode == vsoc::kGpuModeDrmVirgl ||
-      gpu_mode == vsoc::kGpuModeGfxStream) {
-    crosvm_cmd.AddParameter(gpu_mode == vsoc::kGpuModeGfxStream ?
+  if (gpu_mode == cuttlefish::kGpuModeDrmVirgl ||
+      gpu_mode == cuttlefish::kGpuModeGfxStream) {
+    crosvm_cmd.AddParameter(gpu_mode == cuttlefish::kGpuModeGfxStream ?
                                 "--gpu=gfxstream," : "--gpu=",
                             "width=", config_->x_res(), ",",
                             "height=", config_->y_res(), ",",
@@ -193,7 +193,7 @@
 
   if (config_->enable_sandbox()) {
     const bool seccomp_exists = cuttlefish::DirectoryExists(config_->seccomp_policy_dir());
-    const std::string& var_empty_dir = vsoc::kCrosvmVarEmptyDir;
+    const std::string& var_empty_dir = cuttlefish::kCrosvmVarEmptyDir;
     const bool var_empty_available = cuttlefish::DirectoryExists(var_empty_dir);
     if (!var_empty_available || !seccomp_exists) {
       LOG(FATAL) << var_empty_dir << " is not an existing, empty directory."
@@ -263,7 +263,7 @@
   crosvm_cmd.RedirectStdIO(cuttlefish::Subprocess::StdIOChannel::kStdErr,
                            log_out_wr);
 
-  cuttlefish::Command log_tee_cmd(vsoc::DefaultHostArtifactsPath("bin/log_tee"));
+  cuttlefish::Command log_tee_cmd(cuttlefish::DefaultHostArtifactsPath("bin/log_tee"));
   log_tee_cmd.AddParameter("--process_name=crosvm");
   log_tee_cmd.AddParameter("--log_fd_in=", log_out_rd);
 
@@ -273,7 +273,7 @@
   // TODO(schuffelen): QEMU also needs this and this is not the best place for
   // this code. Find a better place to put it.
   auto lease_file =
-      vsoc::ForCurrentInstance("/var/run/cuttlefish-dnsmasq-cvd-wbr-")
+      cuttlefish::ForCurrentInstance("/var/run/cuttlefish-dnsmasq-cvd-wbr-")
       + ".leases";
   if (!ReleaseDhcpLeases(lease_file, wifi_tap)) {
     LOG(ERROR) << "Failed to release wifi DHCP leases. Connecting to the wifi "
diff --git a/host/libs/vm_manager/crosvm_manager.h b/host/libs/vm_manager/crosvm_manager.h
index 2ea9993..95bbb9f 100644
--- a/host/libs/vm_manager/crosvm_manager.h
+++ b/host/libs/vm_manager/crosvm_manager.h
@@ -34,7 +34,7 @@
   static std::vector<std::string> ConfigureGpu(const std::string& gpu_mode);
   static std::vector<std::string> ConfigureBootDevices();
 
-  CrosvmManager(const vsoc::CuttlefishConfig* config);
+  CrosvmManager(const cuttlefish::CuttlefishConfig* config);
   virtual ~CrosvmManager() = default;
 
   std::vector<cuttlefish::Command> StartCommands() override;
diff --git a/host/libs/vm_manager/qemu_manager.cpp b/host/libs/vm_manager/qemu_manager.cpp
index f163bd4..61976be 100644
--- a/host/libs/vm_manager/qemu_manager.cpp
+++ b/host/libs/vm_manager/qemu_manager.cpp
@@ -43,7 +43,7 @@
 
 namespace {
 
-std::string GetMonitorPath(const vsoc::CuttlefishConfig* config) {
+std::string GetMonitorPath(const cuttlefish::CuttlefishConfig* config) {
   return config->ForDefaultInstance()
       .PerInstanceInternalPath("qemu_monitor.sock");
 }
@@ -54,7 +54,7 @@
 }
 
 bool Stop() {
-  auto config = vsoc::CuttlefishConfig::Get();
+  auto config = cuttlefish::CuttlefishConfig::Get();
   auto monitor_path = GetMonitorPath(config);
   auto monitor_sock = cuttlefish::SharedFD::SocketLocalClient(
       monitor_path.c_str(), false, SOCK_STREAM);
@@ -88,7 +88,7 @@
 const std::string QemuManager::name() { return "qemu_cli"; }
 
 std::vector<std::string> QemuManager::ConfigureGpu(const std::string& gpu_mode) {
-  if (gpu_mode != vsoc::kGpuModeGuestSwiftshader) {
+  if (gpu_mode != cuttlefish::kGpuModeGuestSwiftshader) {
     return {};
   }
   // Override the default HAL search paths in all cases. We do this because
@@ -109,7 +109,7 @@
   return { "androidboot.boot_devices=pci0000:00/0000:00:03.0" };
 }
 
-QemuManager::QemuManager(const vsoc::CuttlefishConfig* config)
+QemuManager::QemuManager(const cuttlefish::CuttlefishConfig* config)
   : VmManager(config) {}
 
 std::vector<cuttlefish::Command> QemuManager::StartCommands() {
diff --git a/host/libs/vm_manager/qemu_manager.h b/host/libs/vm_manager/qemu_manager.h
index a1cbaab..cb851ee 100644
--- a/host/libs/vm_manager/qemu_manager.h
+++ b/host/libs/vm_manager/qemu_manager.h
@@ -32,7 +32,7 @@
   static std::vector<std::string> ConfigureGpu(const std::string& gpu_mode);
   static std::vector<std::string> ConfigureBootDevices();
 
-  QemuManager(const vsoc::CuttlefishConfig* config);
+  QemuManager(const cuttlefish::CuttlefishConfig* config);
   virtual ~QemuManager() = default;
 
   std::vector<cuttlefish::Command> StartCommands() override;
diff --git a/host/libs/vm_manager/vm_manager.cpp b/host/libs/vm_manager/vm_manager.cpp
index df44106..26e2122 100644
--- a/host/libs/vm_manager/vm_manager.cpp
+++ b/host/libs/vm_manager/vm_manager.cpp
@@ -28,12 +28,12 @@
 
 namespace vm_manager {
 
-VmManager::VmManager(const vsoc::CuttlefishConfig* config)
+VmManager::VmManager(const cuttlefish::CuttlefishConfig* config)
     : config_(config) {}
 
 namespace{
 template <typename T>
-VmManager* GetManagerSingleton(const vsoc::CuttlefishConfig* config) {
+VmManager* GetManagerSingleton(const cuttlefish::CuttlefishConfig* config) {
   static std::shared_ptr<VmManager> vm_manager(new T(config));
   return vm_manager.get();
 }
@@ -45,7 +45,7 @@
           QemuManager::name(),
           {
             GetManagerSingleton<QemuManager>,
-            vsoc::HostSupportsQemuCli,
+            cuttlefish::HostSupportsQemuCli,
             QemuManager::ConfigureGpu,
             QemuManager::ConfigureBootDevices,
           },
@@ -55,7 +55,7 @@
           {
             GetManagerSingleton<CrosvmManager>,
             // Same as Qemu for the time being
-            vsoc::HostSupportsQemuCli,
+            cuttlefish::HostSupportsQemuCli,
             CrosvmManager::ConfigureGpu,
             CrosvmManager::ConfigureBootDevices,
           }
@@ -63,7 +63,7 @@
     };
 
 VmManager* VmManager::Get(const std::string& vm_manager_name,
-                          const vsoc::CuttlefishConfig* config) {
+                          const cuttlefish::CuttlefishConfig* config) {
   if (VmManager::IsValidName(vm_manager_name)) {
     return vm_manager_helpers_[vm_manager_name].builder(config);
   }
diff --git a/host/libs/vm_manager/vm_manager.h b/host/libs/vm_manager/vm_manager.h
index 33995b2..c70a768 100644
--- a/host/libs/vm_manager/vm_manager.h
+++ b/host/libs/vm_manager/vm_manager.h
@@ -34,7 +34,7 @@
   // if the requested vm manager is not supported by the current version of the
   // host packages
   static VmManager* Get(const std::string& vm_manager_name,
-                        const vsoc::CuttlefishConfig* config);
+                        const cuttlefish::CuttlefishConfig* config);
   static bool IsValidName(const std::string& name);
   static std::vector<std::string> ConfigureGpuMode(
       const std::string& vmm_name, const std::string& gpu_mode);
@@ -67,8 +67,8 @@
                                   const std::pair<int,int>& version,
                                   int major, int minor);
 
-  const vsoc::CuttlefishConfig* config_;
-  VmManager(const vsoc::CuttlefishConfig* config);
+  const cuttlefish::CuttlefishConfig* config_;
+  VmManager(const cuttlefish::CuttlefishConfig* config);
 
   bool frontend_enabled_;
   std::string kernel_cmdline_;
@@ -76,7 +76,7 @@
  private:
   struct VmManagerHelper {
     // The singleton implementation
-    std::function<VmManager*(const vsoc::CuttlefishConfig*)> builder;
+    std::function<VmManager*(const cuttlefish::CuttlefishConfig*)> builder;
     // Whether the host packages support this vm manager
     std::function<bool()> support_checker;
     std::function<std::vector<std::string>(const std::string&)> configure_gpu_mode;