<html devsite>
  <head>
    <title>Requirements</title>
    <meta name="project_path" value="/_project.yaml" />
    <meta name="book_path" value="/_book.yaml" />
  </head>
  <body>
  <!--
      Copyright 2017 The Android Open Source Project

      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.
  -->

<p>
  Before you download and build the Android source, ensure your system meets
  the following requirements then see <a href="initializing.html">Establishing
  a Build Environment</a> for installation instructions by operating system.
</p>

<h2 id=hardware-requirements>Hardware requirements</h2>
<p>
  Your development workstation should meet or exceed these hardware
  requirements:
</p>
<ul>
  <li>A 64-bit environment is required for Android 2.3.x (Gingerbread) and
    higher versions, including the master branch. You can compile older versions
    on 32-bit systems.
  </li>
  <li>At least 250GB of free disk space to checkout the code and an extra 150GB
    to build it. If you conduct multiple builds, you will need even more space.
    <aside class="note"><strong>Note:</strong> If you are checking out a mirror
      you will need more space as full Android Open Source Project (AOSP) mirrors
      contain all Git repositories that have ever been used.</aside>
  </li>
  <li>If you are running Linux in a virtual machine, you need at
    least 16GB of RAM/swap.
  </li>
</ul>

<h2 id=software-requirements>Software requirements</h2>
<p>
  The <a href="https://android.googlesource.com/" class="external">Android Open
  Source Project (AOSP)</a> <code>master</code> branch is traditionally
  developed and tested on Ubuntu Long Term Support (LTS) releases, but other
  distributions may be used. See the list below for recommended versions.
</p>
<p>
  Your workstation must have the software listed below. See
  <a href="initializing.html">Establishing a Build Environment</a> for
  additional required packages and the commands to install them.
</p>
<p>
  These requirements apply to the AOSP master branch. For Android
  versions 8.0 (Oreo or O) through 5.0 (Lollipop or L), consider using the included
  <a href="https://android.googlesource.com/platform/build/+/master/tools/docker">Dockerfile</a>
  to ease installation of all required packages. For the manual method, see
  <a href="older-versions">Supporting Older Versions</a>.
</p>

<h3 id=os>OS</h3>
<p>
  If you are developing against the AOSP <code>master</code> branch, use one of these operating
  systems: Ubuntu 14.04 (Trusty) or the latest versions of Mac OS and Xcode with Command Line Tools
  installed.
</p>

<h3 id=jdk>JDK</h3>
<p>
  The <code>master</code> branch of Android in AOSP comes with a prebuilt version of OpenJDK, so no
  additional installation is required.
</p>
<p>Older versions of Android require a separate installation of the JDK. On Ubuntu, use OpenJDK. See
  <a href="older-versions">Supporting Older Versions</a> for precise versions and instructions.

<h3 id=packages>Key packages</h3>
<p>
  The AOSP master branch comes with a prebuilt version of Make, so no additional installation is
  required.
    </p>
<ul>
  <li><a href="http://ftp.gnu.org/gnu/make/" class="external">GNU Make 3.81 to 3.82</a> for older
    versions</li>
  <li><a href="http://www.python.org/download/" class="external">Python 2.7</a></li>
  <li><a href="http://git-scm.com/download" class="external">Git 1.7 or higher</a></li>
</ul>

<h3 id=binaries>Device binaries</h3>
<p>
  Download previews, factory images, drivers, over-the-air (OTA) updates, and
  other blobs below. For details, see
  <a href="building.html#obtaining-proprietary-binaries">Obtaining proprietary
  binaries</a>.
</p>
<ul>
  <li><a href="https://developers.google.com/android/blobs-preview" class="external">Preview
    binaries (blobs)</a>. For AOSP <code>master</code> branch development.
  </li>
  <li><a href="https://developers.google.com/android/images" class="external">Factory
    images</a>. For supported devices running tagged AOSP release branches.
  </li>
  <li><a href="https://developers.google.com/android/drivers" class="external">Binary
    hardware support files</a>. For devices running tagged AOSP release
    branches.
  </li>
</ul>

<h3 id=toolchain>Build toolchain</h3>
<p>
  Android 8.0 and higher support only
  <a href="https://developer.android.com/ndk/guides/standalone_toolchain.html#working_with_clang" class="external">Clang/LLVM</a>
  for building the Android platform. Join the
  <a href="https://groups.google.com/forum/#!forum/android-llvm" class="external">android-llvm</a>
  group to pose questions and get help. Report NDK/compiler issues at the
  <a href="https://github.com/android-ndk/ndk" class="external">NDK GitHub</a>.
</p>
<p>
  For the
  <a href="https://developer.android.com/ndk/guides/index.html" class="external">Native
  Development Kit (NDK)</a> and legacy kernels, GCC 4.9 included in the AOSP
  master branch (under <code>prebuilts/</code>) may also be used.
</p>
  </body>
</html>
