



<!doctype html>
<html lang="en" class="no-js">
  <head>
    
      <meta charset="utf-8">
      <meta name="viewport" content="width=device-width,initial-scale=1">
      <meta http-equiv="x-ua-compatible" content="ie=edge">
      
      
      
      
        <meta name="lang:clipboard.copy" content="Copy to clipboard">
      
        <meta name="lang:clipboard.copied" content="Copied to clipboard">
      
        <meta name="lang:search.language" content="en">
      
        <meta name="lang:search.pipeline.stopwords" content="True">
      
        <meta name="lang:search.pipeline.trimmer" content="True">
      
        <meta name="lang:search.result.none" content="No matching documents">
      
        <meta name="lang:search.result.one" content="1 matching document">
      
        <meta name="lang:search.result.other" content="# matching documents">
      
        <meta name="lang:search.tokenizer" content="[\s\-]+">
      
      <link rel="shortcut icon" href="../../assets/images/favicon.png">
      <meta name="generator" content="mkdocs-1.0.4, mkdocs-material-4.4.3">
    
    
      
        <title>Installation Guide (Misc) - Team Bliss</title>
      
    
    
      <link rel="stylesheet" href="../../assets/stylesheets/application.30686662.css">
      
      
    
    
      <script src="../../assets/javascripts/modernizr.74668098.js"></script>
    
    
      
        <link href="https://fonts.gstatic.com" rel="preconnect" crossorigin>
        <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,400,400i,700|Roboto+Mono&display=fallback">
        <style>body,input{font-family:"Roboto","Helvetica Neue",Helvetica,Arial,sans-serif}code,kbd,pre{font-family:"Roboto Mono","Courier New",Courier,monospace}</style>
      
    
    <link rel="stylesheet" href="../../assets/fonts/material-icons.css">
    
    
    
      
    
    
  </head>
  
    <body dir="ltr">
  
    <svg class="md-svg">
      <defs>
        
        
      </defs>
    </svg>
    <input class="md-toggle" data-md-toggle="drawer" type="checkbox" id="__drawer" autocomplete="off">
    <input class="md-toggle" data-md-toggle="search" type="checkbox" id="__search" autocomplete="off">
    <label class="md-overlay" data-md-component="overlay" for="__drawer"></label>
    
      <a href="#installation-guide-misc" tabindex="1" class="md-skip">
        Skip to content
      </a>
    
    
      <header class="md-header" data-md-component="header">
  <nav class="md-header-nav md-grid">
    <div class="md-flex">
      <div class="md-flex__cell md-flex__cell--shrink">
        <a href="../.." title="Team Bliss" class="md-header-nav__button md-logo">
          
            <i class="md-icon"></i>
          
        </a>
      </div>
      <div class="md-flex__cell md-flex__cell--shrink">
        <label class="md-icon md-icon--menu md-header-nav__button" for="__drawer"></label>
      </div>
      <div class="md-flex__cell md-flex__cell--stretch">
        <div class="md-flex__ellipsis md-header-nav__title" data-md-component="title">
          
            <span class="md-header-nav__topic">
              Team Bliss
            </span>
            <span class="md-header-nav__topic">
              
                Installation Guide (Misc)
              
            </span>
          
        </div>
      </div>
      <div class="md-flex__cell md-flex__cell--shrink">
        
          <label class="md-icon md-icon--search md-header-nav__button" for="__search"></label>
          
<div class="md-search" data-md-component="search" role="dialog">
  <label class="md-search__overlay" for="__search"></label>
  <div class="md-search__inner" role="search">
    <form class="md-search__form" name="search">
      <input type="text" class="md-search__input" name="query" placeholder="Search" autocapitalize="off" autocorrect="off" autocomplete="off" spellcheck="false" data-md-component="query" data-md-state="active">
      <label class="md-icon md-search__icon" for="__search"></label>
      <button type="reset" class="md-icon md-search__icon" data-md-component="reset" tabindex="-1">
        &#xE5CD;
      </button>
    </form>
    <div class="md-search__output">
      <div class="md-search__scrollwrap" data-md-scrollfix>
        <div class="md-search-result" data-md-component="result">
          <div class="md-search-result__meta">
            Type to start searching
          </div>
          <ol class="md-search-result__list"></ol>
        </div>
      </div>
    </div>
  </div>
</div>
        
      </div>
      
    </div>
  </nav>
</header>
    
    <div class="md-container">
      
        
      
      
      <main class="md-main" role="main">
        <div class="md-main__inner md-grid" data-md-component="container">
          
            
              <div class="md-sidebar md-sidebar--primary" data-md-component="navigation">
                <div class="md-sidebar__scrollwrap">
                  <div class="md-sidebar__inner">
                    <nav class="md-nav md-nav--primary" data-md-level="0">
  <label class="md-nav__title md-nav__title--site" for="__drawer">
    <a href="../.." title="Team Bliss" class="md-nav__button md-logo">
      
        <i class="md-icon"></i>
      
    </a>
    Team Bliss
  </label>
  
  <ul class="md-nav__list" data-md-scrollfix>
    
      
      
      


  <li class="md-nav__item">
    <a href="../.." title="Home" class="md-nav__link">
      Home
    </a>
  </li>

    
      
      
      

  


  <li class="md-nav__item md-nav__item--active md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-2" type="checkbox" id="nav-2" checked>
    
    <label class="md-nav__link" for="nav-2">
      Bliss OS
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-2">
        Bliss OS
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../" title="Index" class="md-nav__link">
      Index
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../build-guide/" title="Build Guide" class="md-nav__link">
      Build Guide
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../extras/" title="Extras" class="md-nav__link">
      Extras
    </a>
  </li>

        
          
          
          

  


  <li class="md-nav__item md-nav__item--active">
    
    <input class="md-toggle md-nav__toggle" data-md-toggle="toc" type="checkbox" id="__toc">
    
      
    
    
      <label class="md-nav__link md-nav__link--active" for="__toc">
        Installation Guide (Misc)
      </label>
    
    <a href="./" title="Installation Guide (Misc)" class="md-nav__link md-nav__link--active">
      Installation Guide (Misc)
    </a>
    
      
<nav class="md-nav md-nav--secondary">
  
  
    
  
  
    <label class="md-nav__title" for="__toc">Table of contents</label>
    <ul class="md-nav__list" data-md-scrollfix>
      
        <li class="md-nav__item">
  <a href="#windows-based-installer-uefiesp-64-bit" class="md-nav__link">
    Windows-based installer - UEFI/ESP (64-bit)
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#part-1-using-the-installer" class="md-nav__link">
    Part 1 - Using the Installer
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-2-switching-the-uefiefi-boot-entry" class="md-nav__link">
    Part 2 - Switching the UEFI/EFI boot entry
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#use-syslinux-efi-to-run-bliss-os-7x10x11x" class="md-nav__link">
    Use syslinux EFI to run Bliss OS 7.x/10.x/11.x
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#part-1-grab-the-required-tools" class="md-nav__link">
    Part 1 - Grab the required tools
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-2-get-bliss-os" class="md-nav__link">
    Part 2 - Get Bliss OS
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-3-get-the-syslinux-efi-bootstrap" class="md-nav__link">
    Part 3 - Get the syslinux EFI bootstrap
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-4-version-specific" class="md-nav__link">
    Part 4 - Version specific
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#if-you-are-using-bliss-7x" class="md-nav__link">
    If you are using Bliss 7.x
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#if-you-are-using-bliss-10x" class="md-nav__link">
    If you are using Bliss 10.x
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-5-creating-the-data-image" class="md-nav__link">
    Part 5 - Creating the data image
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#custom-install-bliss-os-8x10x11x-uefiesp-64-bit" class="md-nav__link">
    Custom Install - Bliss OS 8.x/10.x/11.x UEFI/ESP (64-bit)
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#part-1-mounting-your-uefiesp-partition" class="md-nav__link">
    Part 1 - Mounting Your UEFI/ESP Partition
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#cmd-is-not-showing-up-what-should-i-do" class="md-nav__link">
    cmd is not showing up, what should I do?
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-1-alternate-esp-setup" class="md-nav__link">
    Part 1 (alternate) - ESP setup
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-1-alternate-killing-the-explorerexe" class="md-nav__link">
    Part 1 (alternate) - Killing the explorer.exe
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#part-2-uefi-installation" class="md-nav__link">
    Part 2 - UEFI installation
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#part-4-the-manual-blissification-of-your-pc" class="md-nav__link">
    Part 4 - The Manual Blissification of Your PC
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#install-bliss-os-on-a-vm-virtualbox" class="md-nav__link">
    Install Bliss OS on a VM (virtualbox)
  </a>
  
</li>
      
      
      
      
      
    </ul>
  
</nav>
    
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../installation-guide-surface-devices/" title="Installation Guide (Surface devices)" class="md-nav__link">
      Installation Guide (Surface devices)
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../installation-guide/" title="Installation Guide" class="md-nav__link">
      Installation Guide
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../taking-bug-reports/" title="Taking bug reports" class="md-nav__link">
      Taking bug reports
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../troubleshooting/" title="Troubleshooting" class="md-nav__link">
      Troubleshooting
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

    
      
      
      


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-3" type="checkbox" id="nav-3">
    
    <label class="md-nav__link" for="nav-3">
      BlissRoms
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-3">
        BlissRoms
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../../BlissRoms/" title="Index" class="md-nav__link">
      Index
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../../BlissRoms/build-guide/" title="Build Guide" class="md-nav__link">
      Build Guide
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../../BlissRoms/build-tips/" title="Build Tips" class="md-nav__link">
      Build Tips
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

    
      
      
      


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-4" type="checkbox" id="nav-4">
    
    <label class="md-nav__link" for="nav-4">
      Common
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-4">
        Common
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../../common/" title="Index" class="md-nav__link">
      Index
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../../common/git-started/" title="Git Started" class="md-nav__link">
      Git Started
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../../common/maintaining-proper-authorship/" title="Maintaining proper authorship" class="md-nav__link">
      Maintaining proper authorship
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../../common/using-dippy-bird/" title="Using `dippy-bird`" class="md-nav__link">
      Using `dippy-bird`
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

    
      
      
      


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-5" type="checkbox" id="nav-5">
    
    <label class="md-nav__link" for="nav-5">
      Infrastructure
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-5">
        Infrastructure
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../../infrastructure/" title="Index" class="md-nav__link">
      Index
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

    
  </ul>
</nav>
                  </div>
                </div>
              </div>
            
            
              <div class="md-sidebar md-sidebar--secondary" data-md-component="toc">
                <div class="md-sidebar__scrollwrap">
                  <div class="md-sidebar__inner">
                    
<nav class="md-nav md-nav--secondary">
  
  
    
  
  
    <label class="md-nav__title" for="__toc">Table of contents</label>
    <ul class="md-nav__list" data-md-scrollfix>
      
        <li class="md-nav__item">
  <a href="#windows-based-installer-uefiesp-64-bit" class="md-nav__link">
    Windows-based installer - UEFI/ESP (64-bit)
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#part-1-using-the-installer" class="md-nav__link">
    Part 1 - Using the Installer
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-2-switching-the-uefiefi-boot-entry" class="md-nav__link">
    Part 2 - Switching the UEFI/EFI boot entry
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#use-syslinux-efi-to-run-bliss-os-7x10x11x" class="md-nav__link">
    Use syslinux EFI to run Bliss OS 7.x/10.x/11.x
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#part-1-grab-the-required-tools" class="md-nav__link">
    Part 1 - Grab the required tools
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-2-get-bliss-os" class="md-nav__link">
    Part 2 - Get Bliss OS
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-3-get-the-syslinux-efi-bootstrap" class="md-nav__link">
    Part 3 - Get the syslinux EFI bootstrap
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-4-version-specific" class="md-nav__link">
    Part 4 - Version specific
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#if-you-are-using-bliss-7x" class="md-nav__link">
    If you are using Bliss 7.x
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#if-you-are-using-bliss-10x" class="md-nav__link">
    If you are using Bliss 10.x
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-5-creating-the-data-image" class="md-nav__link">
    Part 5 - Creating the data image
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#custom-install-bliss-os-8x10x11x-uefiesp-64-bit" class="md-nav__link">
    Custom Install - Bliss OS 8.x/10.x/11.x UEFI/ESP (64-bit)
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#part-1-mounting-your-uefiesp-partition" class="md-nav__link">
    Part 1 - Mounting Your UEFI/ESP Partition
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#cmd-is-not-showing-up-what-should-i-do" class="md-nav__link">
    cmd is not showing up, what should I do?
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-1-alternate-esp-setup" class="md-nav__link">
    Part 1 (alternate) - ESP setup
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#part-1-alternate-killing-the-explorerexe" class="md-nav__link">
    Part 1 (alternate) - Killing the explorer.exe
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#part-2-uefi-installation" class="md-nav__link">
    Part 2 - UEFI installation
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#part-4-the-manual-blissification-of-your-pc" class="md-nav__link">
    Part 4 - The Manual Blissification of Your PC
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#install-bliss-os-on-a-vm-virtualbox" class="md-nav__link">
    Install Bliss OS on a VM (virtualbox)
  </a>
  
</li>
      
      
      
      
      
    </ul>
  
</nav>
                  </div>
                </div>
              </div>
            
          
          <div class="md-content">
            <article class="md-content__inner md-typeset">
              
                
                
                <h1 id="installation-guide-misc">Installation Guide (Misc)</h1>
<p>This is only for <strong>advanced users</strong>. For regular users, please visit our main <a href="../installation-guide/">Installation Guide found here.</a></p>
<h2 id="windows-based-installer-uefiesp-64-bit">Windows-based installer - UEFI/ESP (64-bit)</h2>
<p>This method is <strong>no longer supported</strong> due to too many people not understanding computer basics and breaking things. <strong>Proceed at your own risk.</strong> This method might be the easiest currently if you understand what you are doing.</p>
<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>
<h2 id="use-syslinux-efi-to-run-bliss-os-7x10x11x">Use syslinux EFI to run Bliss OS 7.x/10.x/11.x</h2>
<p>Thanks to @IcedCube for the original post! This method is <strong>NOT recommended</strong> as it is fairly bleeding-edge and experimental, but it should help booting on Chinese tablets that do not want to run <code>grub</code>.</p>
<p>Use a Linux installation for the following procedure.</p>
<h3 id="part-1-grab-the-required-tools">Part 1 - Grab the required tools</h3>
<p>Install <code>unsquashfs</code> (part of <code>squashfs-tools</code>).</p>
<h3 id="part-2-get-bliss-os">Part 2 - Get Bliss OS</h3>
<p>Grab the latest build of Bliss OS 7.x/10.x/11.x.</p>
<h3 id="part-3-get-the-syslinux-efi-bootstrap">Part 3 - Get the syslinux EFI bootstrap</h3>
<p><a href="https://forum.xda-developers.com/showpost.php?p=74977694&amp;postcount=1237">Grab the <code>.zip</code> file from @IcedCube's original post</a>, and extract it to the root of the USB drive. This will bootstrap syslinux EFI onto it.</p>
<p>Then, make a folder called <code>android</code>.</p>
<p>Now, open up the <code>.iso</code> in an archive program. Extract the following files form the root directory of the <code>.iso</code> image to the USB drive's <code>android</code> folder:</p>
<ul>
<li><code>initrd.img</code></li>
<li><code>ramdisk.img</code></li>
<li><code>kernel</code></li>
</ul>
<p>Extract <code>system.sfs</code> to a folder somewhere, such as <code>/tmp</code>.</p>
<p>Open a terminal and change directory (using <code>cd</code>) to <code>/tmp</code>. Run <code>ls</code> and confirm that <code>system.sfs</code> is shown in the file list. If there is no output, start over as the file is misplaced.</p>
<p>Run the following:</p>
<p><code>unsquashfs ./system.sfs</code></p>
<p>This will make a new directory called <code>squashfs_root</code>.</p>
<h3 id="part-4-version-specific">Part 4 - Version specific</h3>
<h4 id="if-you-are-using-bliss-7x">If you are using Bliss 7.x</h4>
<p>Change directory to <code>squashfs_root</code> and run <code>ls</code>. There should only be one file - a <code>system.img</code> inside the directory. Copy the file to the USB's <code>android</code> folder.</p>
<h3 id="if-you-are-using-bliss-10x">If you are using Bliss 10.x</h3>
<p>Change directory to <code>squashfs_root</code>. The structure is a complete Android root filesystem. To install Bliss OS, the files will need to be in a system image. The following steps will guide you through creating a 2 GB <code>system.img</code> file, formatting it, mounting it, and copying the contents of <code>squashfs_root</code> into the new disk image.</p>
<p>Execute:</p>
<pre><code>mkdir /mnt/tempMount
truncate /tmp/system.img --size=2G
mkfs.ext4 -m0 /tmp/system.img
sudo mount -o loop /tmp/system.img /mnt/tempMount
sudo cp -prv /tmp/squashfs_root/* /mnt/tempMount/
sync
sudo umount /mnt/tempMount
</code></pre>
<p>The <code>sync</code> command might take some time.</p>
<p>Now copy the <code>/tmp/system.img</code> file to your USB's Android folder.</p>
<h3 id="part-5-creating-the-data-image">Part 5 - Creating the data image</h3>
<p>First, find where your USB drive is mounted. It is usually in <code>/mnt</code> or <code>/media</code> (ex. <code>/media/USB</code>).</p>
<p><code>cd</code> into the <code>android</code> folder.</p>
<p>We will create a 3 GB data image file. You can attempt to create a 4 GB image but FAT32 maxes out at 4 GB per file. If your system supports exFAT or NTFS, you may try and use it.</p>
<pre><code>truncate data.img --size=3G
mkfs.ext4 -m0 data.img
sync
</code></pre>
<p>This will be an completely empty <code>ext4</code> disk image, but will be enough to run Bliss.</p>
<p>Finally, check to ensure everything is in structured like so:</p>
<pre><code>&lt;ROOT&gt;
- syslinux.cfg
- android/
-- kernel
-- system.img
-- data.img
-- ramdisk.img
-- initrd.img
- EFI/
-- BOOT/
--- bootia32.efi
--- bootx64.efi
--- ldlinux.e32
--- ldlinux.e64
</code></pre>
<p>Need to add some kernel parameters? Open <code>syslinux.cfg</code> and add them before the <code>initrd=/android/initrd.img</code> statement.</p>
<p>Unmount the USB from your computer. Plug it into your device and use the BIOS to boot from your UEFI USB Drive, partition 1. If all goes well, you will get a black screen with small white text saying "Booting Android..." followed by loading files. You should get the Linux kernel text, then see the Bliss boot animation play after a couple minutes depending on your USB drive read/write speed.</p>
<h2 id="custom-install-bliss-os-8x10x11x-uefiesp-64-bit">Custom Install - Bliss OS 8.x/10.x/11.x UEFI/ESP (64-bit)</h2>
<p>Just as a reminder, Team Bliss is <strong>NOT</strong> responsible for any damage caused by this guide. By continuing, you automatically agree to these terms.</p>
<h3 id="part-1-mounting-your-uefiesp-partition">Part 1 - Mounting Your UEFI/ESP Partition</h3>
<p>You will want to make sure you can view hidden and system files in Explorer options. Once you do that, hit the start menu, and type in <code>cmd</code>. Once "Command Prompt" shows up, right click on it and choose "Open as administrator".</p>
<h4 id="cmd-is-not-showing-up-what-should-i-do"><code>cmd</code> is not showing up, what should I do?</h4>
<p>Press the Windows key and the R key to bring up the "Run..." dialog. Type in <code>cmd</code>, and then press Ctrl-Shift-Enter. Press "Yes" on the UAC popup.</p>
<p>Run the following:</p>
<pre><code>mountvol X: /S
</code></pre>
<p>Then check to see if it is mounted already. Run "Task Manager" by either</p>
<ul>
<li>Pressing Ctrl-Alt-Del and then clicking on "Task Manager", or</li>
<li>Pressing Ctrl-Shift-Esc</li>
</ul>
<p>Click on "File", "Run new task", "Browse", "This computer", and SYSTEM (X or type in <code>X:</code> in the filepath bar. If you cannot access <code>X:</code>, then that could mean one of three things.</p>
<ul>
<li>You have an ESP setup (follow the installation method below)</li>
<li>You have a legacy MBR setup</li>
<li>Your setup has a custom boot sequence</li>
</ul>
<h3 id="part-1-alternate-esp-setup">Part 1 (alternate) - ESP setup</h3>
<p>Windows 10 sometimes has an EFI partition already mounted under drive letter <code>Z:</code>, hidden. A very quick and easy way to access the ESP (EFI System Partition) in Windows 10 without using the command line is to start "Task Manager" (check above if you forgot the steps), and then click on "File", "Run new task", "Browse", "This computer", and SYSTEM (Z or type in <code>Z:</code> in the filepath bar).</p>
<p>Now go to <code>boot/grub/grub.cfg</code> and edit it accordingly with Notepad++ or another text editor. Save the file and your're ready to go!</p>
<h3 id="part-1-alternate-killing-the-explorerexe">Part 1 (alternate) - Killing the <code>explorer.exe</code></h3>
<p>Run <code>cmd</code> as admin and enter the following command:</p>
<pre><code>taskkill /im explorer.exe /f
</code></pre>
<p>This will kill the <code>explorer.exe</code> process - don't be surprised if it shows a warning. This step is sometimes required, because by default <code>explorer.exe</code> is ran by the currently logged in user, and it has to be run by the "Administrator" in order to view the mounted system drive. <strong>The "Administrator" account is not the same as an account with administrative privileges.</strong></p>
<pre><code>mountvol X: /s
</code></pre>
<p>This will mount the system partition that usually consists of UEFI related files. <code>X:</code> is the letter of the drive - you can use whatever letter you want, but it has to be free for assignment. Then type:</p>
<pre><code>explorer
</code></pre>
<p>This will run <code>explorer</code> as "Administrator" and will allow you to browse the mounted system partition.</p>
<p>The above may not work for all devices, as some handle UEFI differently.</p>
<h2 id="part-2-uefi-installation">Part 2 - UEFI installation</h2>
<p>Let's start by downloading the required files. <a href="https://www.androidfilehost.com/?w=files&amp;flid=143191">Here is a customized UEFI boot for 32/64-bit machines.</a></p>
<p>Please note that if you came from our Nougat builds to our Bliss OS 8.x builds, you will have to edit the <code>grub.cfga</code>.</p>
<p>If you are using Bliss OS 8.x/10.x, please use the <code>grub</code> entry below as a guide:</p>
<pre><code>menuentry 'Bliss-x86' --class android {
    search --file --no-floppy --set=root /AndroidOS/system.sfs
    linux /AndroidOS/kernel root=/dev/ram0 SRC=/AndroidOS androidboot.selinux=permissive androidboot.hardware=android_x86_64 quiet DATA=
    initrd /AndroidOS/initrd.img
}
</code></pre>
<p>If you are installing on <code>ext3</code>/<code>ext4</code>, due to a bug in the install you will have to use the following <code>grub</code> entry setup:</p>
<pre><code>menuentry 'Bliss-x86' --class android {
    search --file --no-floppy --set=root /AndroidOS/system.sfs
    linux /AndroidOS/kernel root=/dev/ram0 SRC=/AndroidOS  androidboot.selinux=permissive androidboot.hardware=android_x86_64 quiet DATA=
    initrd /AndroidOS/initrd.img
}
</code></pre>
<p>Now that we have the partition mounted, we can copy that <code>BOOT</code> directory to your UEFI partition using <code>explorer</code> as the Administrator or by using the "New Task" dialog from Task Manager. (See above if you forgot the steps!) Once it is copied, go back to the Administrator <code>cmd</code> prompt and type:</p>
<pre><code>mountvol X: /D
</code></pre>
<p>or if you used <code>Z:</code>, type:</p>
<pre><code>mountvol Z: /D
</code></pre>
<p>This will dismount the UEFI/ESP volume for safe reboot. We then suggest you use EasyUEFI here to create the UEFI boot entry. Open the app, and create a new entry. Select your UEFI partition, and in the "File" Path, click "Browse" and use the file manager window to browse to your <code>BOOT/grub/grubx64.efi</code> file. Click OK, and then choose the new <code>grub</code> entry and move it to the top. Make sure Secure Boot is turned off or else it likely will just boot back to Windows.</p>
<h3 id="part-4-the-manual-blissification-of-your-pc">Part 4 - The Manual Blissification of Your PC</h3>
<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 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>
                
                  
                
              
              
                


              
            </article>
          </div>
        </div>
      </main>
      
        
<footer class="md-footer">
  
    <div class="md-footer-nav">
      <nav class="md-footer-nav__inner md-grid">
        
          <a href="../extras/" title="Extras" class="md-flex md-footer-nav__link md-footer-nav__link--prev" rel="prev">
            <div class="md-flex__cell md-flex__cell--shrink">
              <i class="md-icon md-icon--arrow-back md-footer-nav__button"></i>
            </div>
            <div class="md-flex__cell md-flex__cell--stretch md-footer-nav__title">
              <span class="md-flex__ellipsis">
                <span class="md-footer-nav__direction">
                  Previous
                </span>
                Extras
              </span>
            </div>
          </a>
        
        
          <a href="../installation-guide-surface-devices/" title="Installation Guide (Surface devices)" class="md-flex md-footer-nav__link md-footer-nav__link--next" rel="next">
            <div class="md-flex__cell md-flex__cell--stretch md-footer-nav__title">
              <span class="md-flex__ellipsis">
                <span class="md-footer-nav__direction">
                  Next
                </span>
                Installation Guide (Surface devices)
              </span>
            </div>
            <div class="md-flex__cell md-flex__cell--shrink">
              <i class="md-icon md-icon--arrow-forward md-footer-nav__button"></i>
            </div>
          </a>
        
      </nav>
    </div>
  
  <div class="md-footer-meta md-typeset">
    <div class="md-footer-meta__inner md-grid">
      <div class="md-footer-copyright">
        
        powered by
        <a href="https://www.mkdocs.org">MkDocs</a>
        and
        <a href="https://squidfunk.github.io/mkdocs-material/">
          Material for MkDocs</a>
      </div>
      
    </div>
  </div>
</footer>
      
    </div>
    
      <script src="../../assets/javascripts/application.ac79c3b0.js"></script>
      
      <script>app.initialize({version:"1.0.4",url:{base:"../.."}})</script>
      
    
  </body>
</html>