diff --git a/Bliss OS/installation-guide/index.html b/Bliss OS/installation-guide/index.html
index 5a35cd1..5cab6cb 100644
--- a/Bliss OS/installation-guide/index.html
+++ b/Bliss OS/installation-guide/index.html
@@ -1037,7 +1037,8 @@
 <p>Plug in your USB drive, and load up Rufus. Once loaded, click on the icon next to the ISO Image dropdown menu. Now browse to where you have your Bliss OS (32-bit) <code>.iso</code>, <em>or</em> your Bliss OS (64-bit) <code>.iso</code>/<code>.img</code> file. Once chosen, the dropdown should switch to the correct image type, and fill the rest in for you. Once you are ready, click Start.</p>
 <h3 id="part-3-testing-bliss-os-on-your-system">Part 3 - Testing Bliss OS on your system</h3>
 <p><strong>This is very important!</strong> If you, as a user, <strong>do NOT</strong> test the OS first to make sure it is compatible with your device, please <strong>do NOT</strong> expect us to help you if you happen to install it blindly and something goes wrong.</p>
-<p>Reboot your machine, and enter the BIOS. Most motherboards have the default key as "F2". Change the boot order so that the USB is the first thing the device will boot to. Once the boot orders are changed, reboot. If everything goes well, you should see a <code>grub</code> boot screen. Select the "Live CD" option, and if your machine is compatible, you should then see a little bit of text, and then the Bliss OS boot animation. This will go on for a few minutes, but should eventually boot to Bliss OS. If the system never boots to Bliss OS, this is a bad sign that your system might not be compatible. If it does boot, and you would like to install it, continue to the next step.</p>
+<p>Reboot your machine, and enter the BIOS. Most motherboards have the default key as "F2". Change the boot order so that the USB is the first thing the device will boot to. Once the boot orders are changed, reboot. If everything goes well, you should see a <code>grub</code> boot screen. Select the "Live CD" option, and if your machine is compatible, you should then see a little bit of text, and then the Bliss OS boot animation. This will go on for a few minutes, but should eventually boot to Bliss OS. If the system never boots to Bliss OS, this is a bad sign that your system might not be compatible. If it does boot, and you would like to install it, continue to the next step.
+For those wanting to use root, you will need to install the OS and be running of that install. Root will not function properly in Live Mode. </p>
 <h4 id="troubleshooting-booting-from-the-usb-kicks-me-back-to-bios-or-back-to-my-windowsmacoslinux-installation">Troubleshooting - Booting from the USB kicks me back to BIOS, or back to my Windows/macOS/Linux installation.</h4>
 <p>Your drive is incompatible or you have formatted it incorrectly. Try flashing the image again to the drive with Rufus. If that does not work, your device does not support booting from USB and you will have to try an alternate method.</p>
 <h3 id="part-3-alternate-using-bliss-os-from-your-usb-drive">Part 3 (alternate) - Using Bliss OS from your USB drive</h3>
@@ -1048,7 +1049,7 @@
 <p>Start off by opening your favorite partition management software, such as Disk Management in Windows, and create a new partition, making it the size you want (suggested minimum is 8 GB). Just format it to NTFS for now, because it will be formatted by the installer later into the process anyway. Remember what drive you have created here as it's important later on. For Windows machines, it will typically be <code>sda4</code> or <code>sda5</code>. Also create another 300 MB FAT32 partition for the <code>grub</code> bootloader to install to. (This part might require a third-party partition manager as Windows Disk Management might not let it be that small.)</p>
 <p>Boot up the Bliss OS USB, and select the "Installation" option in <code>grub</code>. (It is the second one down, usually.)</p>
 <p>The installer will load, and you will have an option to choose the partition you created earlier. Pick it, and select <code>ext4</code>. <strong>DO NOT</strong> blindly choose the partition, as an incorrect flash can mess up your drive and cause serious data loss. <strong>You do NOT want to get this step wrong.</strong> If you are unsure, boot back into Windows/macOS/Linux and write it down.</p>
-<p>When it asks if you want to install system as R/W, select "YES".</p>
+<p>When it asks if you want to install system as R/W, select "YES" if you want to use root (SuperSU), and "No" if you do not need root.</p>
 <p>When it asks if you want to install <code>grub</code>, select "Grub for Legacy BIOS boot type", "Grub2 for UEFI boot type", or neither if you are already running a Linux system. If you chose to install <code>grub</code>, the installer will allow you to choose the partition to install <code>grub</code> to. Make sure you select the 300 MB partition you set up earlier for <code>grub</code>.</p>
 <p>The process will install and create the data directory/image, so be patient. When finished, the installer will then ask if you want to run Android-x86. You can just reboot here. Make sure you remove the USB drive.</p>
 <p>If we have followed all the directions correctly, you should be presented with a <code>grub</code> boot menu. You can choose your <code>bliss_android_x86</code> option (or <code>android-x86</code>), and it will boot into Bliss OS. If you want to customize your <code>grub</code> boot entry, search the web first. We use the same <code>grub</code> setup that the Android-x86 project uses, so their forums will contain just about all the info you will need. </p>
@@ -1058,6 +1059,7 @@
 <p>For the overall instructions on using this method, please refer to the <a href="https://forum.xda-developers.com/android/software/winapp-android-x86-installer-uefi-t3222483">tool's original thread</a>. The tools have been updated by Team Bliss for easy installation on UEFI/ESP machines. The <a href="https://github.com/BlissRoms-x86/Androidx86-Installer-for-Windows/tree/master/bin">builds we produce can be found here.</a> And the <a href="https://github.com/BlissRoms-x86/Androidx86-Installer-for-Windows">source for those builds can be found here.</a> This tool should work on Remix OS as well, but this has not been tested yet.</p>
 <h3 id="part-1-using-the-installer">Part 1 - Using the Installer</h3>
 <p>The installer has been updated to accept the <code>.iso</code> files for our 8.x/10.x/11.x releases. Just follow the prompts the installer gives. Refer to the original thread for any questions, and please search before asking.</p>
+<p>If you plan on using root, the process will require you to manually extract the system.img from within the system.sfs file. Then you must delete the system.sfs file after extracting. </p>
 <p><strong>Warning</strong> - for Pie, you will need to add <code>androidboot.hardware=android_x86_64</code> to the grub entry in order to boot!</p>
 <h3 id="part-2-switching-the-uefiefi-boot-entry">Part 2 - Switching the UEFI/EFI boot entry</h3>
 <p>Option one is to use the EasyUEFI tool, then switch the UEFI/EFI entry it created to boot first. Close and reboot. Option two is to use your BIOS to select the added UEFI boot entry.</p>
