diff --git a/poky/documentation/ref-manual/faq.xml b/poky/documentation/ref-manual/faq.xml
index 49ff862..d94cb32 100644
--- a/poky/documentation/ref-manual/faq.xml
+++ b/poky/documentation/ref-manual/faq.xml
@@ -33,7 +33,7 @@
             <para id='faq-not-meeting-requirements'>
                 My development system does not meet the
                 required Git, tar, and Python versions.
-                In particular, I do not have Python 3.4.0 or greater.
+                In particular, I do not have Python 3.5.0 or greater.
                 Can I still use the Yocto Project?
             </para>
         </question>
@@ -43,7 +43,7 @@
                 system a couple different ways (i.e. building a tarball or
                 downloading a tarball).
                 See the
-                "<link linkend='required-git-tar-and-python-versions'>Required Git, tar, and Python Versions</link>"
+                "<link linkend='required-git-tar-python-and-gcc-versions'>Required Git, tar, Python and gcc Versions</link>"
                 section for steps on how to update your build tools.
             </para>
         </answer>
diff --git a/poky/documentation/ref-manual/migration.xml b/poky/documentation/ref-manual/migration.xml
index 8d50ab9..9422b5a 100644
--- a/poky/documentation/ref-manual/migration.xml
+++ b/poky/documentation/ref-manual/migration.xml
@@ -680,7 +680,7 @@
 
         <para>
             For more information on this requirement, see the
-            "<link linkend='required-git-tar-and-python-versions'>Required Git, tar, and Python Versions</link>"
+            "<link linkend='required-git-tar-python-and-gcc-versions'>Required Git, tar, Python and gcc Versions</link>"
             section.
         </para>
     </section>
@@ -1754,7 +1754,7 @@
             Git that meets this requirement, you can use the
             <filename>buildtools-tarball</filename> that does.
             See the
-            "<link linkend='required-git-tar-and-python-versions'>Required Git, tar, and Python Versions</link>"
+            "<link linkend='required-git-tar-python-and-gcc-versions'>Required Git, tar, Python and gcc Versions</link>"
             section for more information.
         </para>
     </section>
@@ -2110,7 +2110,7 @@
             such as the following:
             <literallayout class='monospaced'>
      inherit bluetooth
-     PACKAGECONFIG ??= "${@bb.utils.contains('DISTRO_FEATURES', 'bluetooth', '${BLUEZ}', '', d)}
+     PACKAGECONFIG ??= "${@bb.utils.contains('DISTRO_FEATURES', 'bluetooth', '${BLUEZ}', '', d)}"
      PACKAGECONFIG[bluez4] = "--enable-bluetooth,--disable-bluetooth,bluez4"
      PACKAGECONFIG[bluez5] = "--enable-bluez5,--disable-bluez5,bluez5"
             </literallayout>
@@ -3215,7 +3215,7 @@
                     recent version, you can install the buildtools, which
                     will provide it.
                     See the
-                    "<link linkend='required-git-tar-and-python-versions'>Required Git, tar, and Python Versions</link>"
+                    "<link linkend='required-git-tar-python-and-gcc-versions'>Required Git, tar, Python and gcc Versions</link>"
                     section for more information on the buildtools tarball.
                     </para></listitem>
                 <listitem><para>
@@ -3624,7 +3624,7 @@
             image types, this part of the kernel image base name as been
             removed leaving only the following:
             <literallayout class='monospaced'>
-     KERNEL_IMAGE_BASE_NAME ?= "${PKGE}-${PKGV}-${PKGR}-${MACHINE}-${DATETIME}
+     KERNEL_IMAGE_BASE_NAME ?= "${PKGE}-${PKGV}-${PKGR}-${MACHINE}-${DATETIME}"
             </literallayout>
             If you have recipes or classes that use
             <filename>KERNEL_IMAGE_BASE_NAME</filename> directly, you might
@@ -5601,7 +5601,7 @@
                     creation time, use
                     <filename>pkg_postinst_ontarget()</filename>
                     or call
-                    <filename>postinst-intercepts defer_to_first_boot</filename>
+                    <filename>postinst_intercept delay_to_first_boot</filename>
                     from <filename>pkg_postinst()</filename>.
                     Any failure of a <filename>pkg_postinst()</filename>
                     script (including <filename>exit 1</filename>)
@@ -6192,7 +6192,7 @@
             If you want to explicitly defer a postinstall to first boot on
             the target rather than at rootfs creation time, use
             <filename>pkg_postinst_ontarget()</filename> or call
-            <filename>postinst-intercepts defer_to_first_boot</filename> from
+            <filename>postinst_intercept delay_to_first_boot</filename> from
             <filename>pkg_postinst()</filename>.
             Any failure of a <filename>pkg_postinst()</filename> script
             (including exit 1) triggers an error during the
@@ -7095,6 +7095,207 @@
     </section>
 </section>
 
+
+<section id='moving-to-the-yocto-project-3.1-release'>
+    <title>Moving to the Yocto Project 3.1 Release</title>
+
+    <para>
+        This section provides migration information for moving to the
+        Yocto Project 3.1 Release from the prior release.
+    </para>
+
+    <section id='migration-3.1-minimum-system-requirements'>
+        <title>Minimum system requirements</title>
+
+        <para>
+            The following versions / requirements of build host components have been updated:
+            <itemizedlist>
+                <listitem><para>gcc 5.0</para></listitem>
+                <listitem><para>python 3.5</para></listitem>
+                <listitem><para>tar 1.28</para></listitem>
+                <listitem><para><filename>rpcgen</filename> is now required on the host (part of the <filename>libc-dev-bin</filename> package on Ubuntu, Debian and related distributions, and the <filename>glibc</filename> package on RPM-based distributions).</para></listitem>
+            </itemizedlist>
+            
+            Additionally, the <filename>makeinfo</filename> and <filename>pod2man</filename>
+            tools are <emphasis>no longer</emphasis> required on the host.
+        </para>
+    </section>
+
+    <section id='migration-3.1-mpc8315e-rdb-removed'>
+        <title>mpc8315e-rdb machine removed</title>
+
+        <para>
+            The MPC8315E-RDB machine is old/obsolete and unobtainable, thus given the maintenance burden
+            the <filename>mpc8315e-rdb</filename> machine configuration that supported it has been removed
+            in this release. The removal does leave a gap in official PowerPC reference hardware
+            support; this may change in future if a suitable machine with accompanying support resources
+            is found.
+        </para>
+    </section>
+    
+    <section id='migration-3.1-python-2-removed'>
+        <title>Python 2 removed</title>
+
+        <para>
+            Due to the expiration of upstream support in January 2020, support for Python 2 has now been removed; it is recommended that you use Python 3 instead. If absolutely needed there is a meta-python2 community layer containing Python 2, related classes and various Python 2-based modules, however it should not be considered as supported.
+        </para>
+    </section>
+
+    <section id='migration-3.1-reproducible-builds'>
+        <title>Reproducible builds now enabled by default</title>
+
+        <para>
+            In order to avoid unnecessary differences in output files (aiding binary reproducibility), the Poky distribution configuration (<filename><link linkend='var-DISTRO'>DISTRO</link> = "poky"</filename>) now inherits the <filename>reproducible_build</filename> class by default.
+        </para>
+    </section>
+    
+    <section id='migration-3.1-ptest-feature-impact'>
+        <title>Impact of ptest feature is now more significant</title>
+
+        <para>
+            The Poky distribution configuration (<filename><link linkend='var-DISTRO'>DISTRO</link> = "poky"</filename>) enables ptests by default to enable runtime testing of various components. In this release, a dependency needed to be added that has resulted in a significant increase in the number of components that will be built just when building a simple image such as core-image-minimal. If you do not need runtime tests enabled for core components, then it is recommended that you remove "ptest" from <link linkend='var-DISTRO_FEATURES'><filename>DISTRO_FEATURES</filename></link> to save a significant amount of build time e.g. by adding the following in your configuration:
+
+            <literallayout class='monospaced'>
+      DISTRO_FEATURES_remove = "ptest"
+            </literallayout>
+        </para>
+    </section>
+
+    <section id='migration-3.1-removed-recipes'>
+        <title>Removed recipes</title>
+
+        <para>
+            The following recipes have been removed:
+
+            <itemizedlist>
+                <listitem><para><filename>chkconfig</filename>: obsolete</para></listitem>
+                <listitem><para><filename>console-tools</filename>: obsolete</para></listitem>
+                <listitem><para><filename>enchant</filename>: replaced by <filename>enchant2</filename></para></listitem>
+                <listitem><para><filename>foomatic-filters</filename>: obsolete</para></listitem>
+                <listitem><para><filename>libidn</filename>: no longer needed, moved to meta-oe</para></listitem>
+                <listitem><para><filename>libmodulemd</filename>: replaced by <filename>libmodulemd-v1</filename></para></listitem>
+                <listitem><para><filename>linux-yocto</filename>: drop 4.19, 5.2 version recipes (5.4 now provided)</para></listitem>
+                <listitem><para><filename>nspr</filename>: no longer needed, moved to meta-oe</para></listitem>
+                <listitem><para><filename>nss</filename>: no longer needed, moved to meta-oe</para></listitem>
+                <listitem><para><filename>python</filename>: Python 2 removed (Python 3 preferred)</para></listitem>
+                <listitem><para><filename>python-setuptools</filename>: Python 2 version removed (python3-setuptools preferred)</para></listitem>
+                <listitem><para><filename>sysprof</filename>: no longer needed, moved to meta-oe</para></listitem>
+                <listitem><para><filename>texi2html</filename>: obsolete</para></listitem>
+                <listitem><para><filename>u-boot-fw-utils</filename>: functionally replaced by <filename>libubootenv</filename></para></listitem>
+            </itemizedlist>
+        </para>
+    </section>
+
+    <section id='migration-3.1-features-check'>
+        <title>features_check class replaces distro_features_check</title>
+
+        <para>
+            The <filename>distro_features_check</filename> class has had its functionality expanded, now supporting <filename>ANY_OF_MACHINE_FEATURES</filename>, <filename>REQUIRED_MACHINE_FEATURES</filename>, <filename>CONFLICT_MACHINE_FEATURES</filename>, <filename>ANY_OF_COMBINED_FEATURES</filename>, <filename>REQUIRED_COMBINED_FEATURES</filename>, <filename>CONFLICT_COMBINED_FEATURES</filename>. As a result the class has now been renamed to <filename>features_check</filename>; the <filename>distro_features_check</filename> class still exists but generates a warning and redirects to the new class. In preparation for a future removal of the old class it is recommended that you update recipes currently inheriting <filename>distro_features_check</filename> to inherit <filename>features_check</filename> instead.
+        </para>
+    </section>
+
+    <section id='migration-3.1-removed-classes'>
+        <title>Removed classes</title>
+
+        <para>
+            The following classes have been removed:
+
+            <itemizedlist>
+                <listitem><para><filename>distutils-base</filename>: moved to meta-python2</para></listitem>
+                <listitem><para><filename>distutils</filename>: moved to meta-python2</para></listitem>
+                <listitem><para><filename>libc-common</filename>: merged into the glibc recipe as nothing else used it.</para></listitem>
+                <listitem><para><filename>python-dir</filename>: moved to meta-python2</para></listitem>
+                <listitem><para><filename>pythonnative</filename>: moved to meta-python2</para></listitem>
+                <listitem><para><filename>setuptools</filename>: moved to meta-python2</para></listitem>
+                <listitem><para><filename>tinderclient</filename>: dropped as it was obsolete.</para></listitem>
+            </itemizedlist>
+        </para>
+    </section>
+
+    <section id='migration-3.1-src-uri-checksums'>
+        <title>SRC_URI checksum behaviour</title>
+
+        <para>
+            Previously, recipes by tradition included both SHA256 and MD5 checksums for remotely fetched files in <link linkend='var-SRC_URI'><filename>SRC_URI</filename></link>, even though only one is actually mandated. However, the MD5 checksum does not add much given its inherent weakness; thus when a checksum fails only the SHA256 sum will now be printed. The md5sum will still be verified if it is specified.
+        </para>
+    </section>
+
+
+    <section id='migration-3.1-npm'>
+        <title>npm fetcher changes</title>
+
+        <para>
+            The npm fetcher has been completely reworked in this release. The npm fetcher now only fetches the package source itself and no longer the dependencies; there is now also an npmsw fetcher which explicitly fetches the shrinkwrap file and the dependencies. This removes the slightly awkward <filename>NPM_LOCKDOWN</filename> and <filename>NPM_SHRINKWRAP</filename> variables which pointed to local files; the lockdown file is no longer needed at all. Additionally, the package name in <filename>npm://</filename> entries in <link linkend='var-SRC_URI'><filename>SRC_URI</filename></link> is now specified using a <filename>package</filename> parameter instead of the earlier <filename>name</filename> which overlapped with the generic <filename>name</filename> parameter. All recipes using the npm fetcher will need to be changed as a result. 
+        </para>
+        <para>
+            An example of the new scheme:
+            <literallayout class='monospaced'>
+SRC_URI = "npm://registry.npmjs.org;package=array-flatten;version=1.1.1 \
+           npmsw://${THISDIR}/npm-shrinkwrap.json"
+            </literallayout>
+            Another example where the sources are fetched from git rather than an npm repository:
+            <literallayout class='monospaced'>
+SRC_URI = "git://github.com/foo/bar.git;protocol=https \
+           npmsw://${THISDIR}/npm-shrinkwrap.json"
+            </literallayout>
+        </para>
+        <para>
+            devtool and recipetool have also been updated to match with the npm fetcher changes. Other than producing working and more complete recipes for npm sources, there is also a minor change to the command line for devtool: the <filename>--fetch-dev</filename> option has been renamed to <filename>--npm-dev</filename> as it is npm-specific.
+        </para>
+    </section>
+    
+    
+    <section id='migration-3.1-packaging-changes'>
+        <title>Packaging changes</title>
+
+        <para>
+            <itemizedlist>
+                <listitem><para><filename>intltool</filename> has been removed from <filename>packagegroup-core-sdk</filename> as it is rarely needed to build modern software - gettext can do most of the things it used to be needed for. <filename>intltool</filename> has also been removed from <filename>packagegroup-core-self-hosted</filename> as it is not needed to for standard builds.</para></listitem>
+                <listitem><para>git: <filename>git-am</filename>, <filename>git-difftool</filename>, <filename>git-submodule</filename>, and <filename>git-request-pull</filename> are no longer perl-based, so are now installed with the main <filename>git</filename> package instead of within <filename>git-perltools</filename>.</para></listitem>
+                <listitem><para>The <filename>ldconfig</filename> binary built as part of glibc has now been moved to its own <filename>ldconfig</filename> package (note no <filename>glibc-</filename> prefix). This package is in the <link linkend='var-RRECOMMENDS'><filename>RRECOMMENDS</filename></link> of the main <filename>glibc</filename> package if <filename>ldconfig</filename> is present in <link linkend='var-DISTRO_FEATURES'><filename>DISTRO_FEATURES</filename></link>.</para></listitem>
+                <listitem><para><filename>libevent</filename> now splits each shared library into its own package (as Debian does). Since these are shared libraries and will be pulled in through the normal shared library dependency handling, there should be no impact to existing configurations other than less unnecessary libraries being installed in some cases.</para></listitem>
+                <listitem><para>linux-firmware now has a new package for <filename>bcm4366c</filename> and includes available NVRAM config files into the <filename>bcm43340</filename>, <filename>bcm43362</filename>, <filename>bcm43430</filename> and <filename>bcm4356-pcie</filename> packages.</para></listitem>
+                <listitem><para><filename>harfbuzz</filename> now splits the new <filename>libharfbuzz-subset.so</filename> library into its own package to reduce the main package size in cases where <filename>libharfbuzz-subset.so</filename> is not needed.</para></listitem>
+            </itemizedlist>
+        </para>
+    </section>
+    
+    <section id='migration-3.1-package-qa-warnings'>
+        <title>Additional warnings</title>
+
+        <para>
+            Warnings will now be shown at <filename>do_package_qa</filename> time in the following circumstances:
+            
+            <itemizedlist>
+                <listitem><para>A recipe installs <filename>.desktop</filename> files containing <filename>MimeType</filename> keys but does not inherit the new <filename>mime-xdg</filename> class</para></listitem>
+                <listitem><para>A recipe installs <filename>.xml</filename> files into <filename>${datadir}/mime/packages</filename> but does not inherit the <filename>mime</filename> class</para></listitem>
+            </itemizedlist>
+        </para>
+    </section>
+        
+    <section id='migration-3.1-x86-live-wic'>
+        <title><filename>wic</filename> image type now used instead of <filename>live</filename> by default for x86</title>
+
+        <para>
+            <filename>conf/machine/include/x86-base.inc</filename> (inherited by most x86 machine configurations) now specifies <filename>wic</filename> instead of <filename>live</filename> by default in <link linkend='var-IMAGE_FSTYPES'><filename>IMAGE_FSTYPES</filename></link>. The <filename>live</filename> image type will likely be removed in a future release so it is recommended that you use <filename>wic</filename> instead.
+        </para>
+    </section>
+                
+    <section id='migration-3.1-misc'>
+        <title>Miscellaneous changes</title>
+
+        <para>
+            <itemizedlist>
+                <listitem><para>The undocumented <filename>SRC_DISTRIBUTE_LICENSES</filename> variable has now been removed in favour of a new <filename>AVAILABLE_LICENSES</filename> variable which is dynamically set based upon license files found in <filename>${COMMON_LICENSE_DIR}</filename> and <filename>${LICENSE_PATH}</filename>.</para></listitem>
+                <listitem><para>The tune definition for big-endian microblaze machines is now <filename>microblaze</filename> instead of <filename>microblazeeb</filename>.</para></listitem>
+                <listitem><para><filename>newlib</filename> no longer has built-in syscalls. <filename>libgloss</filename> should then provide the syscalls, <filename>crt0.o</filename> and other functions that are no longer part of <filename>newlib</filename> itself. If you are using <filename>TCLIBC = "newlib"</filename> this now means that you must link applications with both <filename>newlib</filename> and <filename>libgloss</filename>, whereas before <filename>newlib</filename> would run in many configurations by itself.</para></listitem>
+            </itemizedlist>
+        </para>
+    </section>
+
+</section>
+
+
 </chapter>
 <!--
 vim: expandtab tw=80 ts=4
diff --git a/poky/documentation/ref-manual/ref-features.xml b/poky/documentation/ref-manual/ref-features.xml
index 44ba67c..294b297 100644
--- a/poky/documentation/ref-manual/ref-features.xml
+++ b/poky/documentation/ref-manual/ref-features.xml
@@ -210,6 +210,12 @@
                 <listitem><para><emphasis>usbhost:</emphasis> Include USB Host
                     support (allows to connect external keyboard, mouse,
                     storage, network etc).</para></listitem>
+                <listitem><para><emphasis>usrmerge:</emphasis> Merges the 
+                    <filename>/bin</filename>, <filename>/sbin</filename>, 
+                    <filename>/lib</filename>, and <filename>/lib64</filename>       
+                    directories into their respective counterparts in the 
+                    <filename>/usr</filename> directory to provide better package 
+                   and application compatibility.</para></listitem>
                 <listitem><para><emphasis>wayland:</emphasis> Include the
                     Wayland display server protocol and the library that
                     supports it.</para></listitem>
diff --git a/poky/documentation/ref-manual/ref-manual.xml b/poky/documentation/ref-manual/ref-manual.xml
old mode 100644
new mode 100755
index b442f70..9a914f1
--- a/poky/documentation/ref-manual/ref-manual.xml
+++ b/poky/documentation/ref-manual/ref-manual.xml
@@ -22,11 +22,10 @@
 
         <authorgroup>
             <author>
-                <firstname>Scott</firstname> <surname>Rifenbark</surname>
                 <affiliation>
-                    <orgname>Scotty's Documentation Services, INC</orgname>
+                    <orgname>&ORGNAME;</orgname>
                 </affiliation>
-                <email>srifenbark@gmail.com</email>
+                <email>&ORGEMAIL;</email>
             </author>
 
         </authorgroup>
@@ -34,22 +33,17 @@
         <revhistory>
             <revision>
                 <revnumber>4.0+git</revnumber>
-                <date>24 November 2010</date>
-                <revremark>Released with the Yocto Project 0.9 Release</revremark>
+                <date>November 2010</date>
+                <revremark>The initial document released with the Yocto Project 0.9 Release</revremark>
             </revision>
             <revision>
                 <revnumber>1.0</revnumber>
-                <date>6 April 2011</date>
+                <date>April 2011</date>
                 <revremark>Released with the Yocto Project 1.0 Release.</revremark>
             </revision>
             <revision>
-                <revnumber>1.0.1</revnumber>
-                <date>23 May 2011</date>
-                <revremark>Released with the Yocto Project 1.0.1 Release.</revremark>
-            </revision>
-            <revision>
                 <revnumber>1.1</revnumber>
-                <date>6 October 2011</date>
+                <date>October 2011</date>
                 <revremark>Released with the Yocto Project 1.1 Release.</revremark>
             </revision>
             <revision>
@@ -73,11 +67,6 @@
                 <revremark>Released with the Yocto Project 1.5 Release.</revremark>
             </revision>
             <revision>
-                <revnumber>1.5.1</revnumber>
-                <date>January 2014</date>
-                <revremark>Released with the Yocto Project 1.5.1 Release.</revremark>
-            </revision>
-            <revision>
                 <revnumber>1.6</revnumber>
                 <date>April 2014</date>
                 <revremark>Released with the Yocto Project 1.6 Release.</revremark>
@@ -134,9 +123,14 @@
             </revision>
             <revision>
                 <revnumber>3.0</revnumber>
-                <date>&REL_MONTH_YEAR;</date>
+                <date>October 2019</date>
                 <revremark>Released with the Yocto Project 3.0 Release.</revremark>
             </revision>
+            <revision>
+                <revnumber>3.1</revnumber>
+                <date>&REL_MONTH_YEAR;</date>
+                <revremark>Released with the Yocto Project 3.1 Release.</revremark>
+            </revision>
         </revhistory>
 
     <copyright>
@@ -158,7 +152,7 @@
                        Yocto Project.
                        To be sure you have the latest version of the manual
                        for this release, go to the
-                       <ulink url='&YOCTO_HOME_URL;/documentation'>Yocto Project documentation page</ulink>
+                       <ulink url='&YOCTO_DOCS_URL;'>Yocto Project documentation page</ulink>
                        and select the manual from that site.
                        Manuals from the site are more up-to-date than manuals
                        derived from the Yocto Project released TAR files.
@@ -175,18 +169,20 @@
                        page.
                        If you need a version of this manual for a different
                        Yocto Project release, visit the
-                       <ulink url='&YOCTO_HOME_URL;/documentation'>Yocto Project documentation page</ulink>
+                       <ulink url='&YOCTO_DOCS_URL;'>Yocto Project documentation page</ulink>
                        and select the manual set by using the
                        "ACTIVE RELEASES DOCUMENTATION" or "DOCUMENTS ARCHIVE"
                        pull-down menus.
                        </para></listitem>
-                   <listitem><para>
+                   <listitem>
+                       <para>
                        To report any inaccuracies or problems with this
-                       manual, send an email to the Yocto Project
-                       discussion group at
-                       <filename>yocto@yoctoproject.com</filename> or log into
-                       the freenode <filename>#yocto</filename> channel.
-                       </para></listitem>
+                       (or any other Yocto Project) manual, send an email to
+                       the Yocto Project documentation mailing list at
+                       <filename>docs@lists.yoctoproject.org</filename> or
+                       log into the freenode <filename>#yocto</filename> channel.
+                       </para>
+                   </listitem>
                </itemizedlist>
            </note>
     </legalnotice>
diff --git a/poky/documentation/ref-manual/ref-structure.xml b/poky/documentation/ref-manual/ref-structure.xml
index 8e0c9f5..27f17dd 100644
--- a/poky/documentation/ref-manual/ref-structure.xml
+++ b/poky/documentation/ref-manual/ref-structure.xml
@@ -8,11 +8,11 @@
 
 <para>
     The <link linkend='source-directory'>Source Directory</link>
-    consists of several components.
-    Understanding them and knowing where they are located is key to using the
-    Yocto Project well.
+    consists of numerous files, directories and subdirectories;
+    understanding their locations and contents is key to using the
+    Yocto Project effectively.
     This chapter describes the Source Directory and gives information about
-    the various files and directories.
+    those files and directories.
 </para>
 
 <para>
@@ -22,12 +22,12 @@
     section in the Yocto Project Development Tasks Manual.
 </para>
 
-<note>
-    The OpenEmbedded build system does not support file or directory names that
-    contain spaces.
-    Be sure that the Source Directory you use does not contain these types
-    of names.
-</note>
+    <note>
+        The OpenEmbedded build system does not support file or directory names that
+        contain spaces.
+        Be sure that the Source Directory you use does not contain these types
+        of names.
+    </note>
 
 <section id='structure-core'>
     <title>Top-Level Core Components</title>
@@ -48,18 +48,18 @@
             <link linkend='metadata'>Metadata</link>
             interpreter, reads the Yocto Project Metadata and runs the tasks
             defined by that data.
-            Failures are usually from the Metadata and not from BitBake itself.
-            Consequently, most users do not need to worry about BitBake.
+            Failures are usually caused by errors in your Metadata and not from BitBake itself;
+            consequently, most users do not need to worry about BitBake.
         </para>
 
         <para>
             When you run the <filename>bitbake</filename> command, the
-            main BitBake executable, which resides in the
-            <filename>bitbake/bin/</filename> directory, starts.
+            main BitBake executable (which resides in the
+            <filename>bitbake/bin/</filename> directory) starts.
             Sourcing the environment setup script (i.e.
             <link linkend="structure-core-script"><filename>&OE_INIT_FILE;</filename></link>)
-            places the <filename>scripts</filename> and
-            <filename>bitbake/bin</filename> directories (in that order) into
+            places the <filename>scripts/</filename> and
+            <filename>bitbake/bin/</filename> directories (in that order) into
             the shell's <filename>PATH</filename> environment variable.
         </para>
 
@@ -91,7 +91,7 @@
             by providing a directory name when you <filename>source</filename>
             the setup script.
             For information on separating output from your local
-            Source Directory files, see the
+            Source Directory files (commonly described as an "out of tree" build), see the
             "<link linkend='structure-core-script'><filename>&OE_INIT_FILE;</filename></link>"
             section.
         </para>
@@ -104,8 +104,8 @@
             This directory holds the source for the Yocto Project documentation
             as well as templates and tools that allow you to generate PDF and HTML
             versions of the manuals.
-            Each manual is contained in a sub-folder.
-            For example, the files for this manual reside in
+            Each manual is contained in its own sub-folder;
+            for example, the files for this reference manual reside in
             the <filename>ref-manual/</filename> directory.
         </para>
     </section>
@@ -114,9 +114,9 @@
         <title><filename>meta/</filename></title>
 
         <para>
-            This directory contains the OpenEmbedded-Core metadata.
+            This directory contains the minimal, underlying OpenEmbedded-Core metadata.
             The directory holds recipes, common classes, and machine
-            configuration for emulated targets (<filename>qemux86</filename>,
+            configuration for strictly emulated targets (<filename>qemux86</filename>,
             <filename>qemuarm</filename>, and so forth.)
         </para>
     </section>
@@ -125,8 +125,8 @@
         <title><filename>meta-poky/</filename></title>
 
         <para>
-            This directory contains the configuration for the Poky
-            reference distribution.
+            Designed above the <filename>meta/</filename> content, this directory
+            adds just enough metadata to define the Poky reference distribution.
         </para>
     </section>
 
@@ -148,9 +148,6 @@
             This directory adds additional recipes and append files
             used by the OpenEmbedded selftests to verify the behavior
             of the build system.
-        </para>
-
-        <para>
             You do not have to add this layer to your
             <filename>bblayers.conf</filename> file unless you want to run the
             selftests.
@@ -172,7 +169,7 @@
             This directory contains various integration scripts that implement
             extra functionality in the Yocto Project environment (e.g. QEMU scripts).
             The <link linkend="structure-core-script"><filename>&OE_INIT_FILE;</filename></link>
-            script appends this directory to the shell's
+            script prepends this directory to the shell's
             <filename>PATH</filename> environment variable.
         </para>
 
@@ -202,7 +199,8 @@
             up, a
             <link linkend='build-directory'>Build Directory</link>
             is created, your working directory becomes the Build Directory,
-            and you are presented with a list of common BitBake targets.
+            and you are presented with some simple suggestions as to what to do
+            next, including a list of some possible targets to build.
             Here is an example:
             <literallayout class='monospaced'>
      $ source oe-init-build-env
@@ -217,14 +215,14 @@
          meta-toolchain
          meta-ide-support
 
-     You can also run generated qemu images with a command like 'runqemu qemux86'
+     You can also run generated qemu images with a command like 'runqemu qemux86-64'
             </literallayout>
-            The script gets its default list of common targets from the
-            <filename>conf-notes.txt</filename> file, which is found in the
+            The default output of the <filename>oe-init-build-env</filename> script
+            is from the <filename>conf-notes.txt</filename> file, which is found in the
             <filename>meta-poky</filename> directory within the
             <link linkend='source-directory'>Source Directory</link>.
-            Should you have custom distributions, it is very easy to modify
-            this configuration file to include your targets for your
+            If you design a custom distribution, you can include your own version
+            of this configuration file to mention the targets defined by your
             distribution.
             See the
             "<ulink url='&YOCTO_DOCS_DEV_URL;#creating-a-custom-template-configuration-directory'>Creating a Custom Template Configuration Directory</ulink>"
@@ -234,20 +232,20 @@
 
         <para>
             By default, running this script without a Build Directory
-            argument creates the <filename>build</filename> directory
+            argument creates the <filename>build/</filename> directory
             in your current working directory.
             If you provide a Build Directory argument when you
             <filename>source</filename> the script, you direct the OpenEmbedded
             build system to create a Build Directory of your choice.
             For example, the following command creates a Build Directory named
-            <filename>mybuilds</filename> that is outside of the
+            <filename>mybuilds/</filename> that is outside of the
             <link linkend='source-directory'>Source Directory</link>:
             <literallayout class='monospaced'>
      $ source &OE_INIT_FILE; ~/mybuilds
             </literallayout>
             The OpenEmbedded build system uses the template configuration
             files, which are found by default in the
-            <filename>meta-poky/conf</filename> directory in the
+            <filename>meta-poky/conf/</filename> directory in the
             Source Directory.
             See the
             "<ulink url='&YOCTO_DOCS_DEV_URL;#creating-a-custom-template-configuration-directory'>Creating a Custom Template Configuration Directory</ulink>"
@@ -280,28 +278,26 @@
     <para>
         The OpenEmbedded build system creates the
         <link linkend='build-directory'>Build Directory</link>
-        when you run the build environment setup scripts (i.e.
-        <link linkend='structure-core-script'><filename>&OE_INIT_FILE;</filename></link>).
-    </para>
-
-    <para>
+        when you run the build environment setup script
+        <link
+linkend='structure-core-script'><filename>&OE_INIT_FILE;</filename></link>.
         If you do not give the Build Directory a specific name when you run
-        a setup script, the name defaults to <filename>build</filename>.
+        the setup script, the name defaults to <filename>build/</filename>.
     </para>
 
     <para>
-        The
-        <link linkend='var-TOPDIR'><filename>TOPDIR</filename></link> variable
-        points to the Build Directory.
+        For subsequent parsing and processing, the name of the Build
+        directory is available via the
+        <link linkend='var-TOPDIR'><filename>TOPDIR</filename></link> variable.
     </para>
 
     <section id='structure-build-buildhistory'>
-        <title><filename>build/buildhistory</filename></title>
+        <title><filename>build/buildhistory/</filename></title>
 
         <para>
             The OpenEmbedded build system creates this directory when you
-            enable the build history feature.
-            The directory tracks build information into image, packages, and
+            enable build history via the <filename>buildhistory</filename> class file.
+            The directory organizes build information into image, packages, and
             SDK subdirectories.
             For information on the build history feature, see the
             "<ulink url='&YOCTO_DOCS_DEV_URL;#maintaining-build-output-quality'>Maintaining Build Output Quality</ulink>"
@@ -320,14 +316,14 @@
             Any variable set here overrides any variable set elsewhere within
             the environment unless that variable is hard-coded within a file
             (e.g. by using '=' instead of '?=').
-            Some variables are hard-coded for various reasons but these
+            Some variables are hard-coded for various reasons but such
             variables are relatively rare.
         </para>
 
         <para>
-            Edit this file to set the
-            <filename><link linkend='var-MACHINE'>MACHINE</link></filename>
-            for which you want to build, which package types you wish to use
+            At a minimum, you would normally edit this file to select the target
+            <filename><link linkend='var-MACHINE'>MACHINE</link></filename>,
+            which package types you wish to use
             (<link linkend='var-PACKAGE_CLASSES'><filename>PACKAGE_CLASSES</filename></link>),
             and the location from which you want to access downloaded files
             (<filename><link linkend='var-DL_DIR'>DL_DIR</link></filename>).
@@ -338,16 +334,16 @@
             start the build, the OpenEmbedded build system creates it from
             <filename>local.conf.sample</filename> when
             you <filename>source</filename> the top-level build environment
-            setup script (i.e.
-            <link linkend='structure-core-script'><filename>&OE_INIT_FILE;</filename></link>).
+            setup script
+            <link linkend='structure-core-script'><filename>&OE_INIT_FILE;</filename></link>.
         </para>
 
         <para>
             The source <filename>local.conf.sample</filename> file used
             depends on the <filename>$TEMPLATECONF</filename> script variable,
-            which defaults to <filename>meta-poky/conf</filename>
+            which defaults to <filename>meta-poky/conf/</filename>
             when you are building from the Yocto Project development
-            environment and defaults to <filename>meta/conf</filename> when
+            environment, and to <filename>meta/conf/</filename> when
             you are building from the OpenEmbedded-Core environment.
             Because the script variable points to the source of the
             <filename>local.conf.sample</filename> file, this implies that
@@ -395,11 +391,12 @@
         </para>
 
         <para>
-            The source <filename>bblayers.conf.sample</filename> file used
+            As with the <filename>local.conf</filename> file,
+            the source <filename>bblayers.conf.sample</filename> file used
             depends on the <filename>$TEMPLATECONF</filename> script variable,
-            which defaults to <filename>meta-poky/conf</filename>
+            which defaults to <filename>meta-poky/conf/</filename>
             when you are building from the Yocto Project development
-            environment and defaults to <filename>meta/conf</filename> when
+            environment, and to <filename>meta/conf/</filename> when
             you are building from the OpenEmbedded-Core environment.
             Because the script variable points to the source of the
             <filename>bblayers.conf.sample</filename> file, this implies that
@@ -418,13 +415,13 @@
                 <link linkend='source-directory'>Source Directory</link>.
                 You can find the Yocto Project version of the
                 <filename>bblayers.conf.sample</filename> file in the
-                <filename>meta-poky/conf</filename> directory.
+                <filename>meta-poky/conf/</filename> directory.
             </note>
         </para>
     </section>
 
     <section id='structure-build-conf-sanity_info'>
-        <title><filename>build/conf/sanity_info</filename></title>
+        <title><filename>build/cache/sanity_info</filename></title>
 
         <para>
             This file indicates the state of the sanity checks and is created
@@ -572,8 +569,11 @@
         <title><filename>build/tmp/deploy/images/</filename></title>
 
         <para>
-            This directory receives complete filesystem images.
-            If you want to flash the resulting image from a build onto a device, look here for the image.
+            This directory is populated with the basic output objects of the
+            build (think of them as the "generated artifacts" of the build process),
+            including things like the boot loader image, kernel, root filesystem and more.
+            If you want to flash the resulting image from a build onto a device,
+            look here for the necessary components.
         </para>
 
         <para>
@@ -604,7 +604,7 @@
 
         <para>
             The OpenEmbedded build system creates this directory to hold
-            toolchain installer scripts, which when executed, install the
+            toolchain installer scripts which, when executed, install the
             sysroot that matches your target hardware.
             You can find out more about these installers in the
             "<ulink url='&YOCTO_DOCS_SDK_URL;#sdk-building-an-sdk-installer'>Building an SDK Installer</ulink>"
@@ -1038,7 +1038,7 @@
         <title><filename>meta/recipes-graphics/</filename></title>
 
         <para>
-            This directory contains X and other graphically related system libraries
+            This directory contains X and other graphically related system libraries.
         </para>
     </section>
 
diff --git a/poky/documentation/ref-manual/ref-system-requirements.xml b/poky/documentation/ref-manual/ref-system-requirements.xml
index 9c2198a..7d3c719 100644
--- a/poky/documentation/ref-manual/ref-system-requirements.xml
+++ b/poky/documentation/ref-manual/ref-system-requirements.xml
@@ -8,12 +8,12 @@
     <para>
         Welcome to the Yocto Project Reference Manual!
         This manual provides reference information for the current release
-        of the Yocto Project.
-        The manual is best used after you have an understanding
+        of the Yocto Project, and
+        is most effectively used after you have an understanding
         of the basics of the Yocto Project.
         The manual is neither meant to be read as a starting point to the
-        Yocto Project nor read from start to finish.
-        Use this manual to find variable definitions, class
+        Yocto Project, nor read from start to finish.
+        Rather, use this manual to find variable definitions, class
         descriptions, and so forth as needed during the course of using
         the Yocto Project.
     </para>
@@ -66,12 +66,15 @@
                         below.
                         </para></listitem>
                     <listitem><para>
-                        The Yocto Project is not compatible with the
-                        <ulink url='https://en.wikipedia.org/wiki/Windows_Subsystem_for_Linux'>Windows Subsystem for Linux</ulink>
-                        (WSL).
-                        You cannot use a
-                        <link linkend='hardware-build-system-term'>build host</link>
-                        that is running WSL.
+                        You may use Windows Subsystem For Linux v2 to set up a build
+                        host using Windows 10, but validation is not performed
+                        against build hosts using WSLv2.
+                        <note>
+                          The Yocto Project is not compatible with WSLv1, it is
+                          compatible but not officially supported nor validated
+                          with WSLv2, if you still decide to use WSL please upgrade
+                          to WSLv2.
+                        </note>
                         </para></listitem>
                     <listitem><para>
                         If you encounter problems, please go to
@@ -117,7 +120,7 @@
         <para>
             The list of packages you need on the host development system can
             be large when covering all build scenarios using the Yocto Project.
-            This section provides required packages according to
+            This section describes required packages according to
             Linux distribution and function.
         </para>
 
@@ -127,19 +130,29 @@
             <para>
                 The following list shows the required packages by function
                 given a supported Ubuntu or Debian Linux distribution:
-                <note>
-                    If your build system has the
-                    <filename>oss4-dev</filename> package installed, you
-                    might experience QEMU build failures due to the package
-                    installing its own custom
-                    <filename>/usr/include/linux/soundcard.h</filename> on
-                    the Debian system.
-                    If you run into this situation, either of the following
-                    solutions exist:
-                    <literallayout class='monospaced'>
+                <note><title>Notes</title>
+                    <itemizedlist>
+                        <listitem><para>
+                            If your build system has the
+                            <filename>oss4-dev</filename> package installed, you
+                            might experience QEMU build failures due to the package
+                            installing its own custom
+                            <filename>/usr/include/linux/soundcard.h</filename> on
+                            the Debian system.
+                            If you run into this situation, either of the following
+                            solutions exist:
+                            <literallayout class='monospaced'>
      $ sudo apt-get build-dep qemu
      $ sudo apt-get remove oss4-dev
-                    </literallayout>
+                            </literallayout>
+                        </para></listitem>
+                        <listitem><para>
+                            For Debian-8, <filename>python3-git</filename> and <filename>pylint3</filename> are no longer available via <filename>apt-get</filename>.
+                            <literallayout class='monospaced'>
+     $ sudo pip3 install GitPython pylint==1.9.5
+                            </literallayout>
+                        </para></listitem>
+                    </itemizedlist>
                  </note>
                 <itemizedlist>
                     <listitem><para><emphasis>Essentials:</emphasis>
@@ -205,18 +218,18 @@
             </para>
         </section>
 
-        <section id='centos-packages'>
-            <title>CentOS Packages</title>
+        <section id='centos-7-packages'>
+            <title>CentOS-7 Packages</title>
 
             <para>
                 The following list shows the required packages by function
-                given a supported CentOS Linux distribution:
+                given a supported CentOS-7 Linux distribution:
                 <itemizedlist>
                     <listitem><para><emphasis>Essentials:</emphasis>
                         Packages needed to build an image for a headless
                         system:
                         <literallayout class='monospaced'>
-     $ sudo yum install &CENTOS_HOST_PACKAGES_ESSENTIAL;
+     $ sudo yum install &CENTOS7_HOST_PACKAGES_ESSENTIAL;
                         </literallayout>
                         <note><title>Notes</title>
                             <itemizedlist>
@@ -229,29 +242,81 @@
                                     Linux by default.
                                     You need to install these packages
                                     separately.
-                                    </para></listitem>
+                                </para></listitem>
                                 <listitem><para>
                                     The <filename>makecache</filename> command
                                     consumes additional Metadata from
                                     <filename>epel-release</filename>.
-                                    </para></listitem>
+                                </para></listitem>
                             </itemizedlist>
                         </note>
-                        </para></listitem>
+                    </para></listitem>
                     <listitem><para><emphasis>Documentation:</emphasis>
                         Packages needed if you are going to build out the
                         Yocto Project documentation manuals:
                         <literallayout class='monospaced'>
      $ sudo yum install docbook-style-dsssl docbook-style-xsl \
      docbook-dtds docbook-utils fop libxslt dblatex xmlto
-                        </literallayout></para></listitem>
+                        </literallayout>
+                    </para></listitem>
+                </itemizedlist>
+            </para>
+        </section>
+
+        <section id='centos-8-packages'>
+            <title>CentOS-8 Packages</title>
+
+            <para>
+                The following list shows the required packages by function
+                given a supported CentOS-8 Linux distribution:
+                <itemizedlist>
+                    <listitem><para><emphasis>Essentials:</emphasis>
+                        Packages needed to build an image for a headless
+                        system:
+                        <literallayout class='monospaced'>
+     $ sudo dnf install &CENTOS8_HOST_PACKAGES_ESSENTIAL;
+                        </literallayout>
+                        <note><title>Notes</title>
+                            <itemizedlist>
+                                <listitem><para>
+                                    Extra Packages for Enterprise Linux
+                                    (i.e. <filename>epel-release</filename>)
+                                    is a collection of packages from Fedora
+                                    built on RHEL/CentOS for easy installation
+                                    of packages not included in enterprise
+                                    Linux by default.
+                                    You need to install these packages
+                                    separately.
+                                </para></listitem>
+                                <listitem><para>
+                                    The <filename>PowerTools</filename> repo
+                                    provides additional packages such as
+                                    <filename>rpcgen</filename> and
+                                    <filename>texinfo</filename>.
+                                </para></listitem>
+                                <listitem><para>
+                                    The <filename>makecache</filename> command
+                                    consumes additional Metadata from
+                                    <filename>epel-release</filename>.
+                                </para></listitem>
+                            </itemizedlist>
+                        </note>
+                    </para></listitem>
+                    <listitem><para><emphasis>Documentation:</emphasis>
+                        Packages needed if you are going to build out the
+                        Yocto Project documentation manuals:
+                        <literallayout class='monospaced'>
+     $ sudo dnf install docbook-style-dsssl docbook-style-xsl \
+     docbook-dtds docbook-utils fop libxslt dblatex xmlto
+                        </literallayout>
+                    </para></listitem>
                 </itemizedlist>
             </para>
         </section>
     </section>
 
-    <section id='required-git-tar-and-python-versions'>
-        <title>Required Git, tar, and Python Versions</title>
+    <section id='required-git-tar-python-and-gcc-versions'>
+        <title>Required Git, tar, Python and gcc Versions</title>
 
         <para>
             In order to use the build system, your host development system
@@ -259,8 +324,8 @@
             Python:
             <itemizedlist>
                 <listitem><para>Git 1.8.3.1 or greater</para></listitem>
-                <listitem><para>tar 1.27 or greater</para></listitem>
-                <listitem><para>Python 3.4.0 or greater</para></listitem>
+                <listitem><para>tar 1.28 or greater</para></listitem>
+                <listitem><para>Python 3.5.0 or greater</para></listitem>
             </itemizedlist>
         </para>
 
@@ -272,6 +337,89 @@
             tarball or use BitBake to build the tarball.
         </para>
 
+        <para>
+            In addition, your host development system must meet the following
+            version requirement for gcc:
+            <itemizedlist>
+                <listitem><para>gcc 5.0 or greater</para></listitem>
+            </itemizedlist>
+        </para>
+
+        <para>
+            If your host development system does not meet this requirement,
+            you can resolve this by installing a <filename>buildtools-extended</filename>
+            tarball that contains additional tools, the equivalent of <filename>buildtools-essential</filename>.
+        </para>
+        <section id='installing-a-pre-built-buildtools-tarball-with-install-buildtools-script'>
+            <title>Installing a Pre-Built <filename>buildtools</filename> Tarball with <filename>install-buildtools</filename> script</title>
+
+            <para>
+                The <filename>install-buildtools</filename> script is the easiest
+                of the three methods by which you can get these tools. It downloads
+                a pre-built buildtools installer and automatically installs the tools
+                for you:
+            <orderedlist>
+                <listitem><para>
+                    Execute the <filename>install-buildtools</filename> script.
+                    Here is an example:
+                    <literallayout class='monospaced'>
+     $ cd poky
+     $ scripts/install-buildtools --without-extended-buildtools \
+       --base-url &YOCTO_DL_URL;/releases/yocto \
+       --release yocto-&DISTRO; \
+       --installer-version &DISTRO;
+                    </literallayout>
+                    <para>
+                        During execution, the buildtools tarball will be downloaded,
+                        the checksum of the download will be verified, the installer
+                        will be run for you, and some basic checks will be run to
+                        to make sure the installation is functional.
+                    </para>
+                    <para>
+                        To avoid the need of <filename>sudo</filename> privileges,
+                        the <filename>install-buildtools</filename> script will
+                        by default tell the installer to install in:
+                        <literallayout class='monospaced'>
+     <replaceable>/path/to/</replaceable>poky/buildtools
+                        </literallayout>
+                    </para>
+                    <para>
+                        If your host development system needs the additional tools
+                        provided in the <filename>buildtools-extended</filename>
+                        tarball, you can instead execute the
+                        <filename>install-buildtools</filename> script with the
+                        default parameters:
+                        <literallayout class='monospaced'>
+     $ cd poky
+     $ scripts/install-buildtools
+                        </literallayout>
+                    </para>
+                </para></listitem>
+                <listitem><para>
+                    Source the tools environment setup script by using a
+                    command like the following:
+                    <literallayout class='monospaced'>
+     $ source <replaceable>/path/to/</replaceable>poky/buildtools/environment-setup-x86_64-pokysdk-linux
+                    </literallayout>
+                    Of course, you need to supply your installation directory and be
+                    sure to use the right file (i.e. i586 or x86_64).
+                </para>
+                <para>
+                    After you have sourced the setup script,
+                    the tools are added to <filename>PATH</filename>
+                    and any other environment variables required to run the
+                    tools are initialized.
+                    The results are working versions versions of Git, tar,
+                    Python and <filename>chrpath</filename>. And in the case of
+                    the <filename>buildtools-extended</filename> tarball, additional
+                    working versions of tools including <filename>gcc</filename>,
+                    <filename>make</filename> and the other tools included in
+                    <filename>packagegroup-core-buildessential</filename>.
+                </para></listitem>
+            </orderedlist>
+            </para>
+        </section>
+
         <section id='downloading-a-pre-built-buildtools-tarball'>
             <title>Downloading a Pre-Built <filename>buildtools</filename> Tarball</title>
 
@@ -281,14 +429,18 @@
                 <orderedlist>
                     <listitem><para>
                         Locate and download the <filename>*.sh</filename> at
-                        <ulink url='&YOCTO_DL_URL;/releases/yocto/yocto-&DISTRO;/buildtools/'></ulink>.
+                        <ulink url='&YOCTO_RELEASE_DL_URL;/buildtools/'></ulink>.
                         </para></listitem>
                     <listitem><para>
                         Execute the installation script.
-                        Here is an example:
+                        Here is an example for the traditional installer:
                         <literallayout class='monospaced'>
      $ sh ~/Downloads/x86_64-buildtools-nativesdk-standalone-&DISTRO;.sh
                         </literallayout>
+                        Here is an example for the extended installer:
+                        <literallayout class='monospaced'>
+     $ sh ~/Downloads/x86_64-buildtools-extended-nativesdk-standalone-&DISTRO;.sh
+                        </literallayout>
                         During execution, a prompt appears that allows you to
                         choose the installation directory.
                         For example, you could choose the following:
@@ -311,7 +463,11 @@
                         and any other environment variables required to run the
                         tools are initialized.
                         The results are working versions versions of Git, tar,
-                        Python and <filename>chrpath</filename>.
+                        Python and <filename>chrpath</filename>. And in the case of
+                        the <filename>buildtools-extended</filename> tarball, additional
+                        working versions of tools including <filename>gcc</filename>,
+                        <filename>make</filename> and the other tools included in
+                        <filename>packagegroup-core-buildessential</filename>.
                         </para></listitem>
                 </orderedlist>
             </para>
@@ -327,7 +483,7 @@
                 <filename>.sh</filename> file and then
                 take steps to transfer and run it on a
                 machine that does not meet the minimal Git, tar, and Python
-                requirements.
+                (or gcc) requirements.
             </para>
 
             <para>
@@ -345,6 +501,10 @@
                         <literallayout class='monospaced'>
      $ bitbake buildtools-tarball
                         </literallayout>
+                        or run the BitBake command to build the extended tarball:
+                        <literallayout class='monospaced'>
+                            $ bitbake buildtools-extended-tarball
+                        </literallayout>
                         <note>
                         The
                         <link linkend='var-SDKMACHINE'><filename>SDKMACHINE</filename></link>
@@ -358,21 +518,25 @@
                        subdirectory of the
                        <link linkend='build-directory'>Build Directory</link>.
                        The installer file has the string "buildtools"
-                       in the name.
+                       (or "buildtools-extended") in the name.
                        </para></listitem>
                    <listitem><para>
                        Transfer the <filename>.sh</filename> file from the
                        build host to the machine that does not meet the
-                       Git, tar, or Python requirements.
+                       Git, tar, or Python (or gcc) requirements.
                        </para></listitem>
                    <listitem><para>
                        On the machine that does not meet the requirements,
                        run the <filename>.sh</filename> file
                        to install the tools.
-                       Here is an example:
+                       Here is an example for the traditional installer:
                        <literallayout class='monospaced'>
      $ sh ~/Downloads/x86_64-buildtools-nativesdk-standalone-&DISTRO;.sh
                        </literallayout>
+                       Here is an example for the extended installer:
+                       <literallayout class='monospaced'>
+                           $ sh ~/Downloads/x86_64-buildtools-extended-nativesdk-standalone-&DISTRO;.sh
+                       </literallayout>
                        During execution, a prompt appears that allows you to
                        choose the installation directory.
                        For example, you could choose the following:
@@ -384,10 +548,10 @@
                         Source the tools environment setup script by using a
                         command like the following:
                         <literallayout class='monospaced'>
-     $ source /home/<replaceable>your_username</replaceable>/buildtools/environment-setup-i586-poky-linux
+     $ source /home/<replaceable>your_username</replaceable>/buildtools/environment-setup-x86_64-poky-linux
                         </literallayout>
                         Of course, you need to supply your installation directory and be
-                        sure to use the right file (i.e. i585 or x86-64).
+                        sure to use the right file (i.e. i586 or x86_64).
                         </para>
                         <para>
                         After you have sourced the setup script,
@@ -395,7 +559,11 @@
                         and any other environment variables required to run the
                         tools are initialized.
                         The results are working versions versions of Git, tar,
-                        Python and <filename>chrpath</filename>.
+                        Python and <filename>chrpath</filename>. And in the case of
+                        the <filename>buildtools-extended</filename> tarball, additional
+                        working versions of tools including <filename>gcc</filename>,
+                        <filename>make</filename> and the other tools included in
+                        <filename>packagegroup-core-buildessential</filename>.
                         </para></listitem>
                 </orderedlist>
             </para>
diff --git a/poky/documentation/ref-manual/ref-terms.xml b/poky/documentation/ref-manual/ref-terms.xml
index f985468..722fa7e 100644
--- a/poky/documentation/ref-manual/ref-terms.xml
+++ b/poky/documentation/ref-manual/ref-terms.xml
@@ -41,11 +41,13 @@
                 That append file would match any
                 <filename>busybox_1.21.</filename><replaceable>x</replaceable><filename>.bb</filename>
                 version of the recipe.
-                So, the append file would match the following recipe names:
+                So, the append file would match any of the following recipe names:
                 <literallayout class='monospaced'>
      busybox_1.21.1.bb
      busybox_1.21.2.bb
      busybox_1.21.3.bb
+     busybox_1.21.10.bb
+     busybox_1.21.25.bb
                 </literallayout>
                 <note><title>Important</title>
                     The use of the "<filename>%</filename>" character
@@ -115,7 +117,7 @@
                         in your home directory within the existing
                         directory <filename>mybuilds</filename>:
                         <literallayout class='monospaced'>
-     $cd $HOME
+     $ cd $HOME
      $ source $HOME/poky/&OE_INIT_FILE; $HOME/mybuilds/YP-&POKYVERSION;
                         </literallayout>
                         </para></listitem>
@@ -141,7 +143,7 @@
                 The system used to build images in a Yocto Project
                 Development environment.
                 The build system is sometimes referred to as the
-                development host.
+                <firstterm>development host</firstterm>.
                 </para></listitem>
             <listitem><para>
                 <emphasis>Classes:</emphasis>
@@ -393,7 +395,7 @@
                 Poky is not a product level distro.
                 Rather, it is a good starting point for customization.
                 <note>
-                    Poky began an open-source
+                    Poky began as an open-source
                     project initially developed by OpenedHand.
                     OpenedHand developed Poky from the existing
                     OpenEmbedded build system to create a commercially
diff --git a/poky/documentation/ref-manual/ref-variables.xml b/poky/documentation/ref-manual/ref-variables.xml
index 02abc59..b44fdcb 100644
--- a/poky/documentation/ref-manual/ref-variables.xml
+++ b/poky/documentation/ref-manual/ref-variables.xml
@@ -367,7 +367,7 @@
 
         <glossentry id='var-ASSUME_SHLIBS'><glossterm>ASSUME_SHLIBS</glossterm>
             <info>
-                ASSUME_SHLIBS[doc] = Provides additional shlibs provider mapping information, which adds to or overwrites the information provided automatically by the system."
+                ASSUME_SHLIBS[doc] = "Provides additional shlibs provider mapping information, which adds to or overwrites the information provided automatically by the system."
             </info>
             <glossdef>
                 <para role="glossdeffirst">
@@ -495,6 +495,30 @@
             </glossdef>
         </glossentry>
 
+        <glossentry id='var-AVAILABLE_LICENSES'><glossterm>AVAILABLE_LICENSES</glossterm>
+            <info>
+                AVAILABLE_LICENSES[doc] = "List of licenses found in the directories specified by COMMON_LICENSE_DIR and LICENSE_PATH."
+            </info>
+            <glossdef>
+                <para role="glossdeffirst">
+<!--                <para role="glossdeffirst"><imagedata fileref="figures/define-generic.png" /> -->
+
+                    List of licenses found in the directories specified
+                    by <link linkend='var-COMMON_LICENSE_DIR'><filename>COMMON_LICENSE_DIR</filename></link>
+                    and <link linkend='var-LICENSE_PATH'><filename>LICENSE_PATH</filename></link>.
+
+                    <note>
+                        It is assumed that all changes
+                        to <filename>COMMON_LICENSE_DIR</filename>
+                        and <filename>LICENSE_PATH</filename> have been done
+                        before <filename>AVAILABLE_LICENSES</filename> is
+                        defined
+                        (in <link linkend='ref-classes-license'>license.bbclass</link>).
+                    </note>
+                </para>
+            </glossdef>
+        </glossentry>
+
         <glossentry id='var-AVAILTUNES'><glossterm>AVAILTUNES</glossterm>
             <info>
                 AVAILTUNES[doc] = "The list of defined CPU and Application Binary Interface (ABI) tunings (i.e.  "tunes") available for use by the OpenEmbedded build system."
@@ -1423,7 +1447,7 @@
                     Use the following format to export the variable to the
                     BitBake environment:
                     <literallayout class='monospaced'>
-     export BBSERVER=localhost:$port"
+     export BBSERVER=localhost:$port
                     </literallayout>
                 </para>
 
@@ -3786,7 +3810,7 @@
                     It is not intended to be user-configurable.
                     It is best to just reference the variable to see which distro features are
                     being backfilled for all distro configurations.
-                    See the <link linkend='ref-features-backfill'>Feature Backfilling</link> section for
+                    See the "<link linkend='ref-features-backfill'>Feature Backfilling</link>" section for
                     more information.
                 </para>
             </glossdef>
@@ -6750,6 +6774,25 @@
                     components that are required to produce a functional system
                     image.
                 </note>
+
+                <note><title>Tips</title>
+                    It is possible to define a list of licenses that are allowed
+                    to be used instead of the licenses that are excluded. To do
+                    this, define a
+                    variable <filename>COMPATIBLE_LICENSES</filename> with the
+                    names of the licences that are allowed. Then
+                    define <filename>INCOMPATIBLE_LICENSE</filename> as:
+                    <literallayout class='monospaced'>
+     INCOMPATIBLE_LICENSE = "${@' '.join(sorted(set(d.getVar('AVAILABLE_LICENSES').split()) - set(d.getVar('COMPATIBLE_LICENSES').split())))}"
+                    </literallayout>
+                    This will result
+                    in <filename>INCOMPATIBLE_LICENSE</filename> containing the
+                    names of all licences
+                    from <link linkend='var-AVAILABLE_LICENSES'><filename>AVAILABLE_LICENSES</filename></link>
+                    except the ones specified
+                    in <filename>COMPATIBLE_LICENSES</filename>, thus only
+                    allowing the latter licences to be used.
+                </note>
             </glossdef>
         </glossentry>
 
@@ -7428,7 +7471,6 @@
      KBRANCH_genericx86-64  = "standard/base"
      KBRANCH_edgerouter = "standard/edgerouter"
      KBRANCH_beaglebone = "standard/beaglebone"
-     KBRANCH_mpc8315e-rdb = "standard/fsl-mpc8315e-rdb"
                     </literallayout>
                         The <filename>KBRANCH</filename> statements identify
                         the kernel branch to use when building for each
@@ -8746,7 +8788,6 @@
      MACHINE ?= "genericx86"
      MACHINE ?= "genericx86-64"
      MACHINE ?= "beaglebone"
-     MACHINE ?= "mpc8315e-rdb"
      MACHINE ?= "edgerouter"
                     </literallayout>
                     The last five are Yocto Project reference hardware boards, which
@@ -10376,12 +10417,20 @@
                     <filename>PACKAGECONFIG</filename> blocks are defined
                     in recipes when you specify features and then arguments
                     that define feature behaviors.
-                    Here is the basic block structure:
+                    Here is the basic block structure (broken over multiple
+                    lines for readability):
                     <literallayout class='monospaced'>
      PACKAGECONFIG ??= "f1 f2 f3 ..."
-     PACKAGECONFIG[f1] = "--with-f1,--without-f1,build-deps-f1,rt-deps-f1,rt-recs-f1"
-     PACKAGECONFIG[f2] = "--with-f2,--without-f2,build-deps-f2,rt-deps-f2,rt-recs-f2"
-     PACKAGECONFIG[f3] = "--with-f3,--without-f3,build-deps-f3,rt-deps-f3,rt-recs-f3"
+     PACKAGECONFIG[f1] = "\
+                          --with-f1, \
+                          --without-f1, \
+                          build-deps-for-f1, \
+                          runtime-deps-for-f1, \
+                          runtime-recommends-for-f1, \
+                          packageconfig-conflicts-for-f1 \
+                          "
+     PACKAGECONFIG[f2] = "\
+                         ... and so on and so on ...
                     </literallayout>
                 </para>
 
@@ -10390,7 +10439,7 @@
                     variable itself specifies a space-separated list of the
                     features to enable.
                     Following the features, you can determine the behavior of
-                    each feature by providing up to five order-dependent
+                    each feature by providing up to six order-dependent
                     arguments, which are separated by commas.
                     You can omit any argument you like but must retain the
                     separating commas.
@@ -10420,6 +10469,10 @@
                             (<link linkend='var-RRECOMMENDS'><filename>RRECOMMENDS</filename></link>)
                             that should be added if the feature is enabled.
                             </para></listitem>
+                        <listitem><para>Any conflicting (that is, mutually
+                            exclusive) <filename>PACKAGECONFIG</filename>
+                            settings for this feature.
+                            </para></listitem>
                     </orderedlist>
                 </para>
 
@@ -10427,25 +10480,23 @@
                     Consider the following
                     <filename>PACKAGECONFIG</filename> block taken from the
                     <filename>librsvg</filename> recipe.
-                    In this example the feature is <filename>croco</filename>,
+                    In this example the feature is <filename>gtk</filename>,
                     which has three arguments that determine the feature's
                     behavior.
                     <literallayout class='monospaced'>
-     PACKAGECONFIG ??= "croco"
-     PACKAGECONFIG[croco] = "--with-croco,--without-croco,libcroco"
+     PACKAGECONFIG[gtk] = "--with-gtk3,--without-gtk3,gtk+3"
                     </literallayout>
-                    The <filename>--with-croco</filename> and
-                    <filename>libcroco</filename> arguments apply only if
+                    The <filename>--with-gtk3</filename> and
+                    <filename>gtk+3</filename> arguments apply only if
                     the feature is enabled.
-                    In this case, <filename>--with-croco</filename> is
+                    In this case, <filename>--with-gtk3</filename> is
                     added to the configure script argument list and
-                    <filename>libcroco</filename> is added to
+                    <filename>gtk+3</filename> is added to
                     <filename>DEPENDS</filename>.
                     On the other hand, if the feature is disabled say through
                     a <filename>.bbappend</filename> file in another layer, then
-                    the second argument <filename>--without-croco</filename> is
-                    added to the configure script rather than
-                    <filename>--with-croco</filename>.
+                    the second argument <filename>--without-gtk3</filename> is
+                    added to the configure script instead.
                 </para>
 
                 <para>
@@ -11054,7 +11105,7 @@
 
         <glossentry id='var-PN'><glossterm>PN</glossterm>
             <info>
-                PN[doc] = "PN refers to a recipe name in the context of a file used by the OpenEmbedded build system as input to create a package.
+                PN[doc] = "PN refers to a recipe name in the context of a file used by the OpenEmbedded build system as input to create a package."
             </info>
             <glossdef>
                 <para role="glossdeffirst">
@@ -11501,23 +11552,35 @@
                     By default, a recipe's own
                     <filename><link linkend='var-PN'>PN</link></filename>
                     is implicitly already in its <filename>PROVIDES</filename>
-                    list.
+                    list and therefore does not need to mention that it provides itself.
                     If a recipe uses <filename>PROVIDES</filename>, the
                     additional aliases are synonyms for the recipe and can
-                    be useful satisfying dependencies of other recipes during
+                    be useful for satisfying dependencies of other recipes during
                     the build as specified by
                     <filename><link linkend='var-DEPENDS'>DEPENDS</link></filename>.
                 </para>
 
                 <para>
                     Consider the following example
-                    <filename>PROVIDES</filename> statement from a recipe
-                    file <filename>libav_0.8.11.bb</filename>:
+                    <filename>PROVIDES</filename> statement from the recipe
+                    file <filename>eudev_3.2.9.bb</filename>:
                     <literallayout class='monospaced'>
-     PROVIDES += "libpostproc"
+     PROVIDES = "udev"
                     </literallayout>
                     The <filename>PROVIDES</filename> statement results in
-                    the "libav" recipe also being known as "libpostproc".
+                    the "eudev" recipe also being available as simply "udev".
+
+                    <note>
+                        Given that a recipe's own recipe name is already
+                        implicitly in its own <filename>PROVIDES</filename> list,
+                        it is unnecessary to add aliases with the "+=" operator;
+                        using a simple assignment will be sufficient. In other
+                        words, while you could write:
+                        <literallayout class='monospaced'>
+     PROVIDES += "udev"
+                        </literallayout>
+                        in the above, the "+=" is overkill and unnecessary.
+                    </note>
                 </para>
 
                 <para>
@@ -13383,8 +13446,7 @@
 
         <glossentry id='var-SKIP_FILEDEPS'><glossterm>SKIP_FILEDEPS</glossterm>
             <info>
-                SKIP_FILEDEPS[doc] = "Enables you to remove all files from
-                the "Provides" section of an RPM package."
+                SKIP_FILEDEPS[doc] = "Enables you to remove all files from the 'Provides' section of an RPM package."
             </info>
             <glossdef>
                 <para role="glossdeffirst">
@@ -15331,7 +15393,7 @@
 
         <glossentry id='var-TCLIBC'><glossterm>TCLIBC</glossterm>
             <info>
-                TCLIBC[doc] = "Specifies GNU standard C library (libc) variant to use during the build process. You can select 'glibc', 'musl' or "newlib."
+                TCLIBC[doc] = "Specifies GNU standard C library (libc) variant to use during the build process. You can select 'glibc', 'musl' or 'newlib'."
             </info>
             <glossdef>
                 <para role="glossdeffirst">
@@ -15646,9 +15708,9 @@
 <!--                <para role="glossdeffirst"><imagedata fileref="figures/define-generic.png" /> -->
                     Specifies the target controller to use when running tests
                     against a test image.
-                    The default controller to use is "QemuTarget":
+                    The default controller to use is "qemu":
                     <literallayout class='monospaced'>
-     TEST_TARGET = "QemuTarget"
+     TEST_TARGET = "qemu"
                     </literallayout>
                 </para>
 
@@ -15667,21 +15729,21 @@
                     You can provide the following arguments with
                     <filename>TEST_TARGET</filename>:
                     <itemizedlist>
-                        <listitem><para><emphasis>"QemuTarget":</emphasis>
+                        <listitem><para><emphasis>"qemu":</emphasis>
                             Boots a QEMU image and runs the tests.
                             See the
                             "<ulink url='&YOCTO_DOCS_DEV_URL;#qemu-image-enabling-tests'>Enabling Runtime Tests on QEMU</ulink>"
                             section in the Yocto Project Development Tasks
                             Manual for more information.
                             </para></listitem>
-                        <listitem><para><emphasis>"SimpleRemoteTarget":</emphasis>
+                        <listitem><para><emphasis>"simpleremote":</emphasis>
                             Runs the tests on target hardware that is already
                             up and running.
                             The hardware can be on the network or it can be
                             a device running an image on QEMU.
                             You must also set
                             <link linkend='var-TEST_TARGET_IP'><filename>TEST_TARGET_IP</filename></link>
-                            when you use "SimpleRemoteTarget".
+                            when you use "simpleremote".
                             <note>
                                 This argument is defined in
                                 <filename>meta/lib/oeqa/controllers/simpleremote.py</filename>.
@@ -16473,7 +16535,7 @@
                     Appends a string to the name of the local version of the
                     U-Boot image.
                     For example, assuming the version of the U-Boot image
-                    built was "2013.10, the full version string reported by
+                    built was "2013.10", the full version string reported by
                     U-Boot would be "2013.10-yocto" given the following
                     statement:
                     <literallayout class='monospaced'>
@@ -16771,18 +16833,21 @@
 
         <glossentry id='var-USERADD_ERROR_DYNAMIC'><glossterm>USERADD_ERROR_DYNAMIC</glossterm>
             <info>
-               USERADD_ERROR_DYNAMIC[doc] = "If set to 'error', forces the OpenEmbedded build system to produce an error if the user identification (uid) and group identification (gid) values are not defined in files/passwd and files/group files. If set to 'warn', a warning will be issued instead."
+               USERADD_ERROR_DYNAMIC[doc] = "If set to 'error', forces the OpenEmbedded build system to produce an error if the user identification (uid) and group identification (gid) values are not defined in any of the files listed in USERADD_UID_TABLES and USERADD_GID_TABLES. If set to 'warn', a warning will be issued instead."
             </info>
             <glossdef>
                 <para role="glossdeffirst">
 <!--                <para role="glossdeffirst"><imagedata fileref="figures/define-generic.png" /> -->
-                    If set to "error", forces the OpenEmbedded build system to
-                    produce an error if the user identification
-                    (<filename>uid</filename>) and group identification
-                    (<filename>gid</filename>) values are not defined
-                    in <filename>files/passwd</filename>
-                    and <filename>files/group</filename> files.
-                    If set to "warn", a warning will be issued instead.
+
+                    If set to <filename>error</filename>, forces the
+                    OpenEmbedded build system to produce an error if the user
+                    identification (<filename>uid</filename>) and group
+                    identification (<filename>gid</filename>) values are not
+                    defined in any of the files listed
+                    in <link linkend='var-USERADD_UID_TABLES'><filename>USERADD_UID_TABLES</filename></link>
+                    and <link linkend='var-USERADD_GID_TABLES'><filename>USERADD_GID_TABLES</filename></link>. If
+                    set to <filename>warn</filename>, a warning will be issued
+                    instead.
                 </para>
 
                 <para>
@@ -16809,6 +16874,20 @@
                     <link linkend='var-USERADD_GID_TABLES'><filename>USERADD_GID_TABLES</filename></link>
                     variables.
                 </para>
+
+                <note>
+                    There is a difference in behavior between
+                    setting <filename>USERADD_ERROR_DYNAMIC</filename>
+                    to <filename>error</filename> and setting it
+                    to <filename>warn</filename>. When it is set
+                    to <filename>warn</filename>, the build system will report a
+                    warning for every undefined <filename>uid</filename> and
+                    <filename>gid</filename> in any recipe. But when it is set
+                    to <filename>error</filename>, it will only report errors
+                    for recipes that are actually built. This saves you from
+                    having to add static IDs for recipes that you know will
+                    never be built.
+                </note>
             </glossdef>
         </glossentry>
 
@@ -17108,7 +17187,7 @@
                     "<ulink url='&YOCTO_DOCS_DEV_URL;#creating-partitioned-images-using-wic'>Creating Partitioned Images Using Wic</ulink>"
                     section in the Yocto Project Development Tasks Manual.
                     For details on the kickstart file format, see the
-                    "<link linkend='ref-kickstart'>OpenEmbedded Kickstart (<filename>.wks</filename>) Reference</link>
+                    "<link linkend='ref-kickstart'>OpenEmbedded Kickstart (<filename>.wks</filename>) Reference</link>"
                     Chapter.
                 </para>
             </glossdef>
@@ -17178,8 +17257,7 @@
 
         <glossentry id='var-XSERVER'><glossterm>XSERVER</glossterm>
             <info>
-               XSERVER[doc] = "Specifies the packages that should be installed
-               to provide an X server and drivers for the current machine."
+               XSERVER[doc] = "Specifies the packages that should be installed to provide an X server and drivers for the current machine."
             </info>
             <glossdef>
                 <para role="glossdeffirst">
