diff --git a/Bliss OS/installation-guide/index.html b/Bliss OS/installation-guide/index.html
index 9f43a5f..46e601e 100644
--- a/Bliss OS/installation-guide/index.html
+++ b/Bliss OS/installation-guide/index.html
@@ -1202,9 +1202,15 @@
 <p>To do a manual "Wubi like" install of Bliss OS after you install the UEFI entry, you will need to open the Bliss OS <code>.iso</code>/<code>.img</code> with 7zip, and then drag all the <code>.img</code> &amp; <code>.sfs</code> files to <code>C:/android-x86</code> or whatever your target drive is (make sure your <code>grub</code> entries match where you are putting these). Then create your <code>data.img</code>. We suggest using a tool like RMXtools (use version 1.7) from XDA to create it. Check the tool's thread for detailed instructions. You will want to create your <code>data.img</code> inside that <code>android-x86</code> folder.</p>
 <p>You can now reboot if you have installed the custom UEFI entry right and selected it using EasyUEFI. You should boot right to the Android-x86 <code>grub</code> theme. There, you can use up and down to select, and return to boot that entry. You can also hit <code>e</code> to edit the selected entry. You will want to pay attention to which entry you select, since there will be one for <code>Bliss-x86(32bit)</code> and one or <code>Bliss-x86_64(64bit)</code>.</p>
 <h2 id="install-bliss-os-on-a-vm-virtualbox">Install Bliss OS on a VM (virtualbox)</h2>
-<p>This method does require some beefy PC specs, so it might not work for all. Thanks to Chih-Wei Huang from Android-x86 Project for the detailed information!</p>
-<p>This method is currently being worked on. Check back later for more information!</p>
-<p>Befor we proceed, if things don't work out, check <code>cat /proc/cpuinfo</code> to determine if your CPU is compatible with virtualization.</p>
+<p>This method is <strong>incomplete</strong>, a <strong>work-in-progress</strong>. Android in general do not run great in VMs, because they do not have the proper drivers. As such performance is greatly reduced if you use this method. Please only install Bliss OS in VMs for evaluation, and keep in mind that the performance exhibited by Bliss OS in such an environment is not a true representation of actual performance on bare metal. With that in mind, let's get started!</p>
+<p>First, make sure your CPU is capable of running VMs. For Intel, it is usually Intel VT-x and VT-d. For AMD, it is usually AMD-V. You may also need IOMMU support, although it is probably not necessary since you won't be passing through GPUs.</p>
+<p>Download the latest Bliss OS <code>.iso</code> from our website. Then, download the latest version of VirtualBox, and the latest VirtualBox <strong>extension pack</strong>. Install both executables.</p>
+<p>Once inside VirtualBox, click on "New." For the name, type "Bliss OS." For the type, select <code>Linux</code>, and then <code>Linux 2.6 / 3.x / 4.x (64-bit)</code> for the version. Set memory size to 2048 MB (2 GB) or more. For the disk, accept the default options for the disk type. For the size, set it to 20 GB. VirtualBox should initialize a new virtual machine.</p>
+<p>We need to tweak a couple more settings. Click on "Settings" on the top bar. Allocate more logical processors in System &gt; Processor. Drag the slider to the right, keeping it <strong>inside</strong> the green bar, as you want to leave a couple of logical processors for the host operating system. For the display, try allocating all of the VRAM. (128 MB most likely) Enable 3D Acceleration. Click OK to save settings.</p>
+<p>Now click on Start. VirtualBox will ask you for the CD image. Click on the folder with the green up arrow, and then select the ISO you downloaded earlier.</p>
+<p>Select "Installation - Install Bliss-OS to harddisk" Press D to detect devices. Press C to create and modify partitions. If asked, select No for GPT. Select New, Primary, full size, and then make it bootable. Write to disk. Quit. Select the partition and then reformat to ext4. Select Yes to install GRUB. Select Yes to make the /system directory writable.</p>
+<p>At this point the installation should be complete. But when you reboot, you will notice that the screen is completely black with a cursor at the top-left. This is because there is no display drivers for the virtual machine. Reset the instance, edit the boot parameters, and add <code>nomodeset</code> to the end. Bliss OS should then boot fully.</p>
+<p>Congratulations! You should have a fully working Bliss OS install in a VM, or at least something that works... even if it may be slow. Again, Android on VM is generally not a good idea and you will get a lot more performance if you install Bliss OS to the actual hardware.</p>
 <h2 id="specific-surface-model-instructions">Specific Surface model instructions</h2>
 <p>Reference posts <a href="https://forum.xda-developers.com/showpost.php?p=78015375&amp;postcount=76">here</a> and <a href="https://forum.xda-developers.com/showpost.php?p=76896155&amp;postcount=2107">here</a>.</p>
 <p>Many of you have a Surface device and would like to run Android on it. You're in luck, because this project was started with a Surface Pro 3 to test with back in Android Nougat. The device has since been retired and development has continued on a Surface Book, an IPTS device. This means it requires a specific set of firmware for proper functioning. For all other Surface models, the user must upgrade their own firmware, because it is too large of a burden to build for all Surface models without having those devices to test with.</p>
