diff --git a/poky/documentation/ref-manual/migration.xml b/poky/documentation/ref-manual/migration.xml
index c648d8d..1ecf5b9 100644
--- a/poky/documentation/ref-manual/migration.xml
+++ b/poky/documentation/ref-manual/migration.xml
@@ -4506,8 +4506,8 @@
                     </para></listitem>
                 <listitem><para>
                     <emphasis>fsimage Plug-in Removed:</emphasis>
-                    The Wic fsimage plug-in has been removed as it duplicates
-                    functionality of the rawcopy plug-in.
+                    The Wic fsimage plugin has been removed as it duplicates
+                    functionality of the rawcopy plugin.
                     </para></listitem>
             </itemizedlist>
         </para>
@@ -6325,6 +6325,280 @@
         </para>
     </section>
 </section>
+
+<section id='moving-to-the-yocto-project-2.7-release'>
+    <title>Moving to the Yocto Project 2.7 Release</title>
+
+    <para>
+        This section provides migration information for moving to the
+        Yocto Project 2.7 Release from the prior release.
+    </para>
+
+    <section id='migration-2.7-bitbake-changes'>
+        <title>BitBake Changes</title>
+
+        <para>
+            The following changes have been made to BitBake:
+            <itemizedlist>
+                <listitem><para>
+                    BitBake now checks anonymous Python functions and pure
+                    Python functions (e.g. <filename>def funcname:</filename>)
+                    in the metadata for tab indentation.
+                    If found, BitBake  produces a warning.
+                    </para></listitem>
+                <listitem><para>
+                    Bitbake now checks
+                    <link linkend='var-BBFILE_COLLECTIONS'><filename>BBFILE_COLLECTIONS</filename></link>
+                    for duplicate entries and triggers an error if any are
+                    found.
+                    </para></listitem>
+            </itemizedlist>
+        </para>
+    </section>
+
+    <section id='migration-2.7-eclipse-support-dropped'>
+        <title><trademark class='trade'>Eclipse</trademark> Support Removed</title>
+
+        <para>
+            Support for the Eclipse IDE has been removed.
+            Support continues for those releases prior to 2.7 that did include
+            support.
+            The 2.7 release does not include the Eclipse Yocto plugin.
+        </para>
+    </section>
+
+    <section id='migration-2.7-qemu-native-splits-system-and-user-mode-parts'>
+        <title><filename>qemu-native</filename> Splits the System and User-Mode Parts</title>
+
+        <para>
+            The system and user-mode parts of <filename>qemu-native</filename>
+            are now split.
+            <filename>qemu-native</filename> provides the user-mode components
+            and <filename>qemu-system-native</filename> provides the system
+            components.
+            If you have recipes that depend on QEMU's system emulation
+            functionality at build time, they should now depend upon
+            <filename>qemu-system-native</filename> instead of
+            <filename>qemu-native</filename>.
+        </para>
+    </section>
+
+    <section id='migration-2.7-upstream-tracking.inc-removed'>
+        <title>The <filename>upstream-tracking.inc</filename> File Has Been Removed</title>
+
+        <para>
+            The previously deprecated <filename>upstream-tracking.inc</filename>
+            file is now removed.
+            Any <filename>UPSTREAM_TRACKING*</filename> variables are now set
+            in the corresponding recipes instead.
+        </para>
+
+        <para>
+            Remove any references you have to the
+            <filename>upstream-tracking.inc</filename> file in your
+            configuration.
+        </para>
+    </section>
+
+    <section id='migration-2.7-distro-features-libc-removed'>
+        <title>The <filename>DISTRO_FEATURES_LIBC</filename> Variable Has Been Removed</title>
+
+        <para>
+            The <filename>DISTRO_FEATURES_LIBC</filename> variable is no
+            longer used.
+            The ability to configure glibc using kconfig has been removed
+            for quite some time making the <filename>libc-*</filename> features
+            set no longer effective.
+        </para>
+
+        <para>
+            Remove any references you have to
+            <filename>DISTRO_FEATURES_LIBC</filename> in your own layers.
+        </para>
+    </section>
+
+    <section id='migration-2.7-license-values'>
+        <title>License Value Corrections</title>
+
+        <para>
+            The following corrections have been made to the
+            <link linkend='var-LICENSE'><filename>LICENSE</filename></link>
+            values set by recipes:
+            <literallayout class='monospaced'>
+     <emphasis>socat</emphasis>: Corrected <filename>LICENSE</filename> to be "GPLv2" rather than
+        "GPLv2+".
+
+     <emphasis>libgfortran</emphasis>: Set license to "GPL-3.0-with-GCC-exception".
+
+     <emphasis>elfutils</emphasis>: Removed "Elfutils-Exception" and set to "GPLv2" for shared
+        libraries
+            </literallayout>
+        </para>
+    </section>
+
+    <section id='migration-2.7-packaging-changes'>
+        <title>Packaging Changes</title>
+
+        <para>
+            This section provides information about packaging changes.
+            <itemizedlist>
+                <listitem><para>
+                    <filename>bind</filename>: The
+                    <filename>nsupdate</filename> binary has been moved to
+                    the <filename>bind-utils</filename> package.
+                    </para></listitem>
+                <listitem><para>
+                    Debug split: The default debug split has been changed to
+                    create separate source packages (i.e.
+                    <replaceable>package_name</replaceable><filename>-dbg</filename>
+                    and
+                    <replaceable>package_name</replaceable><filename>-src</filename>).
+                    If you are currently using <filename>dbg-pkgs</filename>
+                    in
+                    <link linkend='var-IMAGE_FEATURES'><filename>IMAGE_FEATURES</filename></link>
+                    to bring in debug symbols and you still need the sources,
+                    you must now also add <filename>src-pkgs</filename> to
+                    <filename>IMAGE_FEATURES</filename>.
+                    Source packages remain in the target portion of the SDK
+                    by default, unless you have set your own value for
+                    <link linkend='var-SDKIMAGE_FEATURES'><filename>SDKIMAGE_FEATURES</filename></link>
+                    that does not include <filename>src-pkgs</filename>.
+                    </para></listitem>
+                <listitem><para>
+                    Mount all using <filename>util-linux</filename>:
+                    <filename>/etc/default/mountall</filename> has
+                    moved into the -mount sub-package.
+                    </para></listitem>
+                <listitem><para>
+                    Splitting binaries using <filename>util-linux</filename>:
+                    <filename>util-linux</filename> now splits each binary into
+                    its own package for fine-grained control.
+                    The main <filename>util-linux</filename> package pulls in
+                    the individual binary packages using the
+                    <link linkend='var-RRECOMMENDS'><filename>RRECOMMENDS</filename></link>
+                    and
+                    <link linkend='var-RDEPENDS'><filename>RDEPENDS</filename></link>
+                    variables.
+                    As a result, existing images should not see any changes
+                    assuming
+                    <link linkend='var-NO_RECOMMENDATIONS'><filename>NO_RECOMMENDATIONS</filename></link>
+                    is not set.
+                    </para></listitem>
+                <listitem><para>
+                    <filename>netbase/base-files</filename>:
+                    <filename>/etc/hosts</filename> has moved from
+                    <filename>netbase</filename> to
+                    <filename>base-files</filename>.
+                    </para></listitem>
+                <listitem><para>
+                    <filename>tzdata</filename>: The main package has been
+                    converted to an empty meta package that pulls in all
+                    <filename>tzdata</filename> packages by default.
+                    </para></listitem>
+                <listitem><para>
+                    <filename>lrzsz</filename>: This package has been removed
+                    from <filename>packagegroup-self-hosted</filename> and
+                    <filename>packagegroup-core-tools-testapps</filename>.
+                    The X/Y/ZModem support is less likely to be needed on
+                    modern systems.
+                    If you are relying on these packagegroups to include the
+                    <filename>lrzsz</filename> package in your image, you
+                    now need to explicitly add the package.
+                    </para></listitem>
+            </itemizedlist>
+        </para>
+    </section>
+
+    <section id='migration-2.7-removed-recipes'>
+        <title>Removed Recipes</title>
+
+        <para>
+            The following recipes have been removed:
+            <literallayout class='monospaced'>
+     <emphasis>gcc</emphasis>: Drop version 7.3 recipes. Version 8.3 now remains.
+
+     <emphasis>linux-yocto</emphasis>: Drop versions 4.14 and 4.18 recipes. Versions 4.19 and 5.0 remain.
+
+     <emphasis>go</emphasis>: Drop version 1.9 recipes. Versions 1.11 and 1.12 remain.
+
+     <emphasis>xvideo-tests</emphasis>: Became obsolete.
+
+     <emphasis>libart-lgpl</emphasis>: Became obsolete.
+
+     <emphasis>gtk-icon-utils-native</emphasis>: These tools are now provided by gtk+3-native
+
+     <emphasis>gcc-cross-initial</emphasis>: No longer needed. gcc-cross/gcc-crosssdk is now used instead.
+
+     <emphasis>gcc-crosssdk-initial</emphasis>: No longer needed. gcc-cross/gcc-crosssdk is now used instead.
+
+     <emphasis>glibc-initial</emphasis>: Removed because the benefits of having it for site_config are
+        currently outweighed by the cost of building the recipe.
+            </literallayout>
+         </para>
+    </section>
+
+    <section id='migration-2.7-removed-classes'>
+        <title>Removed Classes</title>
+
+        <para>
+            The following classes have been removed:
+            <literallayout class='monospaced'>
+     <emphasis>distutils-tools</emphasis>: This class was never used.
+
+     <emphasis>bugzilla.bbclass</emphasis>: Became obsolete.
+
+     <emphasis>distrodata</emphasis>: This functionally has been replaced by a more modern
+         tinfoil-based implementation.
+            </literallayout>
+        </para>
+    </section>
+
+    <section id='migration-2.7-miscellaneous-changes'>
+        <title>Miscellaneous Changes</title>
+
+        <para>
+            The following miscellaneous changes occurred:
+            <itemizedlist>
+                <listitem><para>
+                    The <filename>distro</filename> subdirectory of the Poky
+                    repository has been removed from the top-level
+                    <filename>scripts</filename> directory.
+                    </para></listitem>
+                <listitem><para>
+                    Perl now builds for the target using
+                    <ulink url='http://arsv.github.io/perl-cross/'><filename>perl-cross</filename></ulink>
+                    for better maintainability and improved build performance.
+                    This change should not present any problems unless you have
+                    heavily customized your Perl recipe.
+                    </para></listitem>
+                <listitem><para>
+                    <filename>arm-tunes</filename>: Removed the "-march"
+                    option if mcpu is already added.
+                    </para></listitem>
+                <listitem><para>
+                    <filename>update-alternatives</filename>: Convert file
+                    renames to
+                    <link linkend='var-PACKAGE_PREPROCESS_FUNCS'><filename>PACKAGE_PREPROCESS_FUNCS</filename></link>
+                    </para></listitem>
+                <listitem><para>
+                    <filename>base/pixbufcache</filename>: Obsolete
+                    <filename>sstatecompletions</filename> code has been
+                    removed.
+                    </para></listitem>
+                <listitem><para>
+                    <link linkend='ref-classes-native'><filename>native</filename></link>
+                    class:
+                    <link linkend='var-RDEPENDS'><filename>RDEPENDS</filename></link>
+                    handling has been enabled.
+                    </para></listitem>
+                <listitem><para>
+                    <filename>inetutils</filename>: This recipe has rsh
+                    disabled.
+                    </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 cb74df6..7a3555d 100644
--- a/poky/documentation/ref-manual/ref-features.xml
+++ b/poky/documentation/ref-manual/ref-features.xml
@@ -342,9 +342,6 @@
             class.
             The current list of these valid features is as follows:
             <itemizedlist>
-                <listitem><para><emphasis>eclipse-debug:</emphasis> Provides
-                    Eclipse remote debugging support.
-                    </para></listitem>
                 <listitem><para><emphasis>hwcodecs:</emphasis> Installs
                     hardware acceleration codecs.
                     </para></listitem>
diff --git a/poky/documentation/ref-manual/ref-kickstart.xml b/poky/documentation/ref-manual/ref-kickstart.xml
index a58f9d7..1128bd5 100644
--- a/poky/documentation/ref-manual/ref-kickstart.xml
+++ b/poky/documentation/ref-manual/ref-kickstart.xml
@@ -117,9 +117,9 @@
                     This option is a Wic-specific option that names the source
                     of the data that populates the partition.
                     The most common value for this option is "rootfs", but you
-                    can use any value that maps to a valid source plug-in.
-                    For information on the source plug-ins, see the
-                    "<ulink url='&YOCTO_DOCS_DEV_URL;#wic-using-the-wic-plug-ins-interface'>Using the Wic Plug-Ins Interface</ulink>"
+                    can use any value that maps to a valid source plugin.
+                    For information on the source plugins, see the
+                    "<ulink url='&YOCTO_DOCS_DEV_URL;#wic-using-the-wic-plugin-interface'>Using the Wic Plugins Interface</ulink>"
                     section in the Yocto Project Development Tasks Manual.
                     </para>
 
@@ -139,12 +139,12 @@
                     <filename>--source <replaceable>plugin-name</replaceable></filename>,
                     Wic creates a partition as large as needed and fills it
                     with the contents of the partition that is generated by the
-                    specified plug-in name using the data pointed to by the
+                    specified plugin name using the data pointed to by the
                     <filename>-r</filename> command-line option or the
                     equivalent rootfs derived from the <filename>-e</filename>
                     command-line option.
                     Exactly what those contents are and filesystem type used are
-                    dependent on the given plug-in implementation.
+                    dependent on the given plugin implementation.
                     </para>
 
                     <para>If you do not use the <filename>--source</filename>
@@ -220,7 +220,7 @@
                     This option is a Wic-specific option that excludes the given
                     relative path from the resulting image.
                     This option is only effective with the rootfs source
-                    plug-in.
+                    plugin.
                     </para></listitem>
                 <listitem><para>
                     <emphasis><filename>--extra-space</filename>:</emphasis>
@@ -299,7 +299,7 @@
             supports the following options:
             <note>
                 Bootloader functionality and boot partitions are implemented by
-                the various <filename>--source</filename> plug-ins that
+                the various <filename>--source</filename> plugins that
                 implement bootloader functionality.
                 The bootloader command essentially provides a means of
                 modifying bootloader configuration.
diff --git a/poky/documentation/ref-manual/ref-manual-eclipse-customization.xsl b/poky/documentation/ref-manual/ref-manual-eclipse-customization.xsl
deleted file mode 100644
index f3b7521..0000000
--- a/poky/documentation/ref-manual/ref-manual-eclipse-customization.xsl
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version='1.0'?>
-<xsl:stylesheet
-	xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-	xmlns="http://www.w3.org/1999/xhtml"
-	xmlns:fo="http://www.w3.org/1999/XSL/Format"
-	version="1.0">
-
-  <xsl:import href="http://downloads.yoctoproject.org/mirror/docbook-mirror/docbook-xsl-1.76.1/eclipse/eclipse3.xsl" />
-
-<!--
-
-  <xsl:import href="../template/1.76.1/docbook-xsl-1.76.1/eclipse/eclipse3.xsl" />
-
-  <xsl:import
-	  href="http://docbook.sourceforge.net/release/xsl/1.76.1/eclipse/eclipse3.xsl" />
-
--->
-
-  <xsl:param name="chunker.output.indent" select="'yes'"/>
-  <xsl:param name="chunk.quietly" select="1"/>
-  <xsl:param name="chunk.first.sections" select="1"/>
-  <xsl:param name="chunk.section.depth" select="10"/>
-  <xsl:param name="use.id.as.filename" select="1"/>
-  <xsl:param name="ulink.target" select="'_self'" />
-  <xsl:param name="base.dir" select="'html/ref-manual/'"/>
-  <xsl:param name="html.stylesheet" select="'../book.css'"/>
-  <xsl:param name="eclipse.manifest" select="0"/>
-  <xsl:param name="create.plugin.xml" select="0"/>
-  <xsl:param name="suppress.navigation" select="1"/>
-  <xsl:param name="generate.index" select="0"/>
-  <xsl:param name="chapter.autolabel" select="1" />
-  <xsl:param name="appendix.autolabel">A</xsl:param>
-  <xsl:param name="section.autolabel" select="1" />
-  <xsl:param name="section.label.includes.component.label" select="1" />
-</xsl:stylesheet>
diff --git a/poky/documentation/ref-manual/ref-manual.xml b/poky/documentation/ref-manual/ref-manual.xml
index 26295f0..fc43197 100644
--- a/poky/documentation/ref-manual/ref-manual.xml
+++ b/poky/documentation/ref-manual/ref-manual.xml
@@ -129,9 +129,14 @@
             </revision>
             <revision>
                 <revnumber>2.7</revnumber>
-                <date>&REL_MONTH_YEAR;</date>
+                <date>May 2019</date>
                 <revremark>Released with the Yocto Project 2.7 Release.</revremark>
             </revision>
+            <revision>
+                <revnumber>2.8</revnumber>
+                <date>&REL_MONTH_YEAR;</date>
+                <revremark>Released with the Yocto Project 2.8 Release.</revremark>
+            </revision>
         </revhistory>
 
     <copyright>
diff --git a/poky/documentation/ref-manual/ref-system-requirements.xml b/poky/documentation/ref-manual/ref-system-requirements.xml
index 5f2b9f6..239dd84 100644
--- a/poky/documentation/ref-manual/ref-system-requirements.xml
+++ b/poky/documentation/ref-manual/ref-system-requirements.xml
@@ -91,6 +91,7 @@
                 <listitem><para>Ubuntu 16.04 (LTS)</para></listitem>
                 <listitem><para>Ubuntu 18.04</para></listitem>
                 <listitem><para>Fedora 28</para></listitem>
+                <listitem><para>Fedora 29</para></listitem>
                 <listitem><para>CentOS 7.x</para></listitem>
                 <listitem><para>Debian GNU/Linux 8.x (Jessie)</para></listitem>
                 <listitem><para>Debian GNU/Linux 9.x (Stretch)</para></listitem>
diff --git a/poky/documentation/ref-manual/ref-terms.xml b/poky/documentation/ref-manual/ref-terms.xml
index c573a52..f985468 100644
--- a/poky/documentation/ref-manual/ref-terms.xml
+++ b/poky/documentation/ref-manual/ref-terms.xml
@@ -183,16 +183,11 @@
             <listitem><para id='term-container-layer'>
                 <emphasis>Container Layer:</emphasis>
                 Layers that hold other layers.
-                An example of a container layer is the
-                <filename>meta-intel</filename> layer.
-                This layer contains BSP layers for the Intel-core2-32
-                <trademark class='registered'>Intel</trademark> Common Core
-                (Intel-core2-32) and the Intel-corei7-64
-                <trademark class='registered'>Intel</trademark> Common Core
-                (Intel-corei7-64).
-                the <filename>meta-intel</filename> layer also contains
-                the <filename>common/</filename> directory, which contains
-                common content across those layers.
+                An example of a container layer is OpenEmbedded's
+                <ulink url='https://github.com/openembedded/meta-openembedded'><filename>meta-openembedded</filename></ulink>
+                layer.
+                The <filename>meta-openembedded</filename> layer contains
+                many <filename>meta-*</filename> layers.
                 </para></listitem>
             <listitem><para id='cross-development-toolchain'>
                 <emphasis>Cross-Development Toolchain:</emphasis>
diff --git a/poky/documentation/ref-manual/ref-variables.xml b/poky/documentation/ref-manual/ref-variables.xml
index 536bd15..0d01c16 100644
--- a/poky/documentation/ref-manual/ref-variables.xml
+++ b/poky/documentation/ref-manual/ref-variables.xml
@@ -11309,7 +11309,7 @@
                     Here are two examples:
                     <literallayout class='monospaced'>
      PREFERRED_VERSION_python = "3.4.0"
-     PREFERRED_VERSION_linux-yocto = "4.12%"
+     PREFERRED_VERSION_linux-yocto = "5.0%"
                     </literallayout>
                     <note><title>Important</title>
                         The use of the "<filename>%</filename>" character
@@ -11355,14 +11355,14 @@
                     to set a machine-specific override.
                     Here is an example:
                     <literallayout class='monospaced'>
-     PREFERRED_VERSION_linux-yocto_qemux86 = "4.12%"
+     PREFERRED_VERSION_linux-yocto_qemux86 = "5.0%"
                     </literallayout>
                     Although not recommended, worst case, you can also use the
                     "forcevariable" override, which is the strongest override
                     possible.
                     Here is an example:
                     <literallayout class='monospaced'>
-     PREFERRED_VERSION_linux-yocto_forcevariable = "4.12%"
+     PREFERRED_VERSION_linux-yocto_forcevariable = "5.0%"
                     </literallayout>
                     <note>
                         The <filename>_forcevariable</filename> override is
@@ -12609,7 +12609,7 @@
                     is set to "minimal" to keep the SDK reasonably small
                     but you still want to provide a usable toolchain.
                     For example, suppose you want to use the toolchain from an
-                    IDE (e.g. Eclipse) or from other tools and you do not
+                    IDE or from other tools and you do not
                     want to perform additional steps to install the toolchain.
                 </para>
 
@@ -13722,6 +13722,9 @@
                             a secure shell.</para></listitem>
                         <listitem><para><emphasis><filename>svn://</filename> -</emphasis> Fetches files from
                             a Subversion (<filename>svn</filename>) revision control repository.</para></listitem>
+                        <listitem><para><emphasis><filename>npm://</filename> -</emphasis> Fetches JavaScript
+                            modules from a registry.
+                            </para></listitem>
                     </itemizedlist>
                 </para>
 
diff --git a/poky/documentation/ref-manual/resources.xml b/poky/documentation/ref-manual/resources.xml
index 6a0cee8..afe8e28 100644
--- a/poky/documentation/ref-manual/resources.xml
+++ b/poky/documentation/ref-manual/resources.xml
@@ -247,14 +247,6 @@
                 </para></listitem>
             <listitem><para>
                 <emphasis>
-                <ulink url='&YOCTO_DOCS_SDK_URL;#adt-eclipse'>Eclipse IDE Yocto Plug-in</ulink>:
-                </emphasis>
-                Instructions that demonstrate how an application developer
-                uses the Eclipse Yocto Project Plug-in feature within
-                the Eclipse IDE.
-                </para></listitem>
-            <listitem><para>
-                <emphasis>
                 <ulink url='&YOCTO_WIKI_URL;/wiki/FAQ'>FAQ</ulink>:
                 </emphasis>
                 A list of commonly asked questions and their answers.
