diff --git a/README.md b/README.md
index 4ff8d12..615de85 100644
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@
   * How to [install Bazel](http://bazel.io/docs/install.html)
   * How to [get started using Bazel](http://bazel.io/docs/getting-started.html)
   * The Bazel command line is documented in the  [user manual](http://bazel.io/docs/bazel-user-manual.html)
-  * The rule reference documentation is in the [build encyclopedia](http://bazel.io/docs/build-encyclopedia.html)
+  * The rule reference documentation is in the [build encyclopedia](http://bazel.io/docs/be/overview.html)
   * How to [use the query command](http://bazel.io/docs/query.html)
   * How to [extend Bazel](http://bazel.io/docs/skylark/index.html)
   * The test environment is described in the [test encyclopedia](http://bazel.io/docs/test-encyclopedia.html)
diff --git a/site/blog/_posts/2015-09-01-beta-release.md b/site/blog/_posts/2015-09-01-beta-release.md
index 3e7a940..4627804 100644
--- a/site/blog/_posts/2015-09-01-beta-release.md
+++ b/site/blog/_posts/2015-09-01-beta-release.md
@@ -24,7 +24,7 @@
 * Binary releases for
   [Linux and OS X](https://github.com/bazelbuild/bazel/releases).
 * Support for building and testing C++, Java, Python, Rust,
-  [and more](http://bazel.io/docs/build-encyclopedia.html).
+  [and more](http://bazel.io/docs/be/overview.html).
 * Support for building Docker images, Android apps, and iOS apps.
 * Support for using libraries from
   [Maven, GitHub, and more](http://bazel.io/docs/external.html).
diff --git a/site/docs/bazel-user-manual.html b/site/docs/bazel-user-manual.html
index 84b1a67..ea925e1 100644
--- a/site/docs/bazel-user-manual.html
+++ b/site/docs/bazel-user-manual.html
@@ -1032,9 +1032,9 @@
 </h4>
 <p>
   The <code>experimental_action_listener</code> option instructs Bazel to use
-  details from the <a href="build-encyclopedia.html#action_listener"
+  details from the <a href="be/extra-actions.html#action_listener"
   ><code>action_listener</code></a> rule specified by <var>label</var> to
-  insert <a href="build-encyclopedia.html#extra_action"
+  insert <a href="be/extra-actions.html#extra_action"
   ><code>extra_actions</code></a> into the build graph.
 </p>
 
@@ -1212,7 +1212,7 @@
 <p>
   Build rules can also specify link options in their attributes. This option's
   settings always take precedence. Also see
-  <a href="build-encyclopedia.html#cc_library.linkopts">cc_library.linkopts</a>.
+  <a href="be/c-cpp.html#cc_library.linkopts">cc_library.linkopts</a>.
 </p>
 
 <h4 id='flag--strip'><code class='flag'>--strip (always|never|sometimes)</code></h4>
@@ -1246,7 +1246,7 @@
 <h4 id='flag--stripopt'><code class='flag'>--stripopt <var>strip-option</var></code></h4>
 <p>
   An additional option to pass to the <code>strip</code> command when generating
-  a <a href="build-encyclopedia.html#cc_binary_implicit_outputs"><code>*.stripped</code>
+  a <a href="be/c-cpp.html#cc_binary_implicit_outputs"><code>*.stripped</code>
   binary</a>. The default is <code>-S -p</code>. This option can be used
   multiple times.
 </p>
@@ -1575,7 +1575,7 @@
 <h4 id='flag--dynamic_mode'><code class='flag'>--dynamic_mode <var>mode</var></code></h4>
 <p>
   Determines whether C++ binaries will be linked dynamically, interacting with
-  the <a href='build-encyclopedia.html#cc_binary.linkstatic'>linkstatic
+  the <a href='be/c-cpp.html#cc_binary.linkstatic'>linkstatic
   attribute</a> on build rules.
 </p>
 
@@ -1586,14 +1586,14 @@
   <li><code>auto</code>: Translates to a platform-dependent mode;
       <code>default</code> for linux and <code>off</code> for cygwin.</li>
   <li><code>default</code>: Allows bazel to choose whether to link dynamically.
-      See <a href='build-encyclopedia.html#cc_binary.linkstatic'>linkstatic</a> for more
+      See <a href='be/c-cpp.html#cc_binary.linkstatic'>linkstatic</a> for more
       information.</li>
   <li><code>fully</code>: Links all targets dynamically.  This will speed up
       linking time, and reduce the size of the resulting binaries.
 
   </li>
   <li><code>off</code>: Links all targets in
-      <a href='build-encyclopedia.html#cc_binary.linkstatic'>mostly static</a> mode.
+      <a href='be/c-cpp.html#cc_binary.linkstatic'>mostly static</a> mode.
       If <code>-static</code> is set in linkopts, targets will change to fully
       static.</li>
 </ul>
@@ -1705,7 +1705,7 @@
   This options set the label or the path of the base Java installation to use
   for running JavaBuilder, SingleJar, and is also used for bazel run and inside
   Java binaries built by <code>java_binary</code> rules. The various
-  <a href='build-encyclopedia.html#make_variables'>"Make" variables</a> for
+  <a href='be/make-variables.html'>"Make" variables</a> for
   Java (<code>JAVABASE</code>, <code>JAVA</code>, <code>JAVAC</code> and
   <code>JAR</code>) are derived from this option.
 </p>
@@ -2140,7 +2140,7 @@
 <h4 id='flag--test_lang_filters'><code class='flag'>--test_lang_filters <var>lang[,lang]*</var></code></h4>
 <p>
   Specifies a comma-separated list of test languages for languages with an official <code>*_test</code> rule the
-  (see <a href="build-encyclopedia.html">build encyclopedia</a> for a full list of these). Each
+  (see <a href="be/overview.html">build encyclopedia</a> for a full list of these). Each
   language can be optionally preceded with '-' to specify excluded
   languages.  The name used for each language should be the same as
   the language prefix in the <code>*_test</code> rule, for example,
@@ -2350,7 +2350,7 @@
 <p>
   Stamping can be enabled or disabled explicitly in BUILD using
   the <code>stamp</code> attribute of certain rule types, please refer to
-  the <a href="build-encyclopedia.html">build encyclopedia</a> for details. For
+  the <a href="be/overview.html">build encyclopedia</a> for details. For
   rules that are neither explicitly or implicitly configured as <code>stamp =
   0</code> or <code>stamp = 1</code>, the <code class='flag'>--[no]stamp</code> option
   selects whether stamping is enabled. Bazel never stamps binaries that are
@@ -3046,7 +3046,7 @@
   </li>
   <li>
     The complete
-    <a href='build-encyclopedia.html#make_variables'
+    <a href='be/make-variables.html'
     >"Make" environment</a>. If the <code class='flag'>--show_make_env</code> flag is
     specified, all variables in the current configuration's "Make" environment
     are also displayed (e.g. <code>CC</code>, <code>GLIBC_VERSION</code>, etc).
diff --git a/site/docs/build-ref.html b/site/docs/build-ref.html
index 71c3bed..eed9bf7 100644
--- a/site/docs/build-ref.html
+++ b/site/docs/build-ref.html
@@ -89,7 +89,7 @@
   A package is a container.  The elements of a package are called
   <i>targets</i>. Most targets are one of two principal kinds, <i>files</i>
   and <i>rules</i>. Additionally, there is another kind of target,
-  <a href="build-encyclopedia.html#package_group">package groups</a>,
+  <a href="be/functions.html#package_group">package groups</a>,
   but they are far less numerous.
 </p>
 
@@ -246,7 +246,7 @@
   <i>visibility</i> attribute of rules or from the <i>default_visibility</i>
   attribute of the <i>package</i> function; they do not generate or consume
   files. For more information, refer to the appropriate section of the
-  <a href='build-encyclopedia.html#package_group'>Build Encyclopedia</a>.
+  <a href='be/functions.html#package_group'>Build Encyclopedia</a>.
 </p>
 
 
@@ -443,7 +443,7 @@
   kinds or <i>classes</i>, which produce compiled
   executables and libraries, test executables and other supported
   outputs as described in the
-  <a href="build-encyclopedia.html">Build Encyclopedia</a>.
+  <a href="be/overview.html">Build Encyclopedia</a>.
 </p>
 
 <p>
@@ -461,7 +461,7 @@
   Every rule has a set of <i>attributes</i>; the applicable attributes
   for a given rule, and the significance and semantics of each
   attribute are a function of the rule's class; see
-  the <a href='build-encyclopedia.html'>Build
+  the <a href='be/overview.html'>Build
   Encyclopedia</a> for the full list of supported rules and their
   corresponding attributes.  Each attribute has a name and a
   type.  The full set of types that an attribute can have is: integer,
@@ -774,12 +774,11 @@
   libraries, and tests, respectively.  Other languages use the same
   naming scheme, with a different prefix, e.g. <code>java_*</code> for
   Java. These functions are all documented in the
-  <a href="build-encyclopedia.html">Build Encyclopedia</a>.
+  <a href="be/overview.html">Build Encyclopedia</a>.
 </p>
 
 <ul>
-  <li><p>A <a href='build-encyclopedia.html#binary'><code>*_binary</code></a>
-
+  <li><p>A <code>*_binary</code>
       rule builds an executable program in a given language.  After a
       build, the executable will reside in the build tool's binary
       output tree at the corresponding name for the rule's label,
@@ -794,7 +793,7 @@
       one place for ease of deployment to production.</p>
   </li>
 
-  <li><p>A <a href='build-encyclopedia.html#test'><code>*_test</code></a>
+  <li><p>A <code>*_test</code>
       rule is a specialization of a *_binary rule, used for automated
       testing.  Tests are simply programs that return zero on success.
 
@@ -816,7 +815,7 @@
     </p>
   </li>
 
-  <li>A <a href='build-encyclopedia.html#library'><code>*_library</code></a>
+  <li>A <code>*_library</code>
     rule specifies a separately-compiled module in the given
     programming language.  Libraries can depend on other libraries,
     and binaries and tests can depend on libraries, with the expected
@@ -1036,7 +1035,7 @@
   Most build rules have three attributes for specifying different kinds
   of generic dependencies: <code>srcs</code>, <code>deps</code> and
   <code>data</code>. These are explained below. See also
-  <a href='build-encyclopedia.html#common-attributes'>Attributes common
+  <a href='be/common-definitions.html'>Attributes common
   to all rules</a> in the Build Encyclopedia.)
 </p>
 
@@ -1136,8 +1135,8 @@
        Rather than specifying directories as inputs to the build system,
        you should enumerate the set of files contained within them, either
        explicitly or using the
-       <a href='build-encyclopedia.html#glob'><code>glob()</code></a> function.
-       (Use <code>**</code> to force the <a href='build-encyclopedia.html#glob'>
+       <a href='be/functions.html#glob'><code>glob()</code></a> function.
+       (Use <code>**</code> to force the <a href='be/functions.html#glob'>
        <code>glob()</code></a> to be recursive.)
    </p>
 
@@ -1150,7 +1149,7 @@
       names do not conform to the strict <a href='#lexi'>label syntax</a>
       (e.g. they contain certain punctuation symbols), then explicit
       enumeration of files, or use of the
-      <a href='build-encyclopedia.html#glob'><code>glob()</code></a> function will
+      <a href='be/functions.html#glob'><code>glob()</code></a> function will
       produce an invalid labels error.  You must use directory labels in this case,
       but beware of the concomitant risk of incorrect rebuilds described above.
    </p>
diff --git a/site/docs/external.md b/site/docs/external.md
index 6777cf6..f8fbc64 100644
--- a/site/docs/external.md
+++ b/site/docs/external.md
@@ -14,7 +14,7 @@
 [workspace directory](/docs/build-ref.html#workspaces). This `WORKSPACE` file
 uses the same Python-like syntax of BUILD files, but allows a different set of
 rules. See the full list of rules that are allowed in the
-[Workspace](/docs/build-encyclopedia.html#workspace) list of rules in the Build
+[Workspace](/docs/be/workspace.html) list of rules in the Build
 Encyclopedia.
 
 ## Fetching dependencies
@@ -99,8 +99,8 @@
 
 If you have a second Bazel project that you'd like to use targets from, you can
 use
-[`local_repository`](http://bazel.io/docs/build-encyclopedia.html#local_repository)
-or [`http_archive`](http://bazel.io/docs/build-encyclopedia.html#http_archive)
+[`local_repository`](http://bazel.io/docs/be/workspace.html#local_repository)
+or [`http_archive`](http://bazel.io/docs/be/workspace.html#http_archive)
 to symlink it from the local filesystem or download it (respectively).
 
 For example, suppose you are working on a project, `my-project/`, and you want
@@ -122,8 +122,8 @@
 ## Depending on non-Bazel projects
 
 Rules prefixed with `new_` (e.g.,
-[`new_local_repository`](http://bazel.io/docs/build-encyclopedia.html#new_local_repository)
-and [`new_http_archive`](http://bazel.io/docs/build-encyclopedia.html#new_http_archive)
+[`new_local_repository`](http://bazel.io/docs/be/workspace.html#new_local_repository)
+and [`new_http_archive`](http://bazel.io/docs/be/workspace.html#new_http_archive)
 ) allow you to create targets from projects that do not use Bazel.
 
 For example, suppose you are working on a project, `my-project/`, and you want
diff --git a/site/docs/getting-started.md b/site/docs/getting-started.md
index 18d89bc..510445b 100644
--- a/site/docs/getting-started.md
+++ b/site/docs/getting-started.md
@@ -77,7 +77,7 @@
 Java source files Bazel should compile into a Java binary.
 `glob(["**/*.java"])` is a handy shorthand for "recursively include every file
 that ends with .java" (see the
-[build encyclopedia](build-encyclopedia.html#glob) for more information about
+[build encyclopedia](be/functions.html#glob) for more information about
 globbing). `com.example.ProjectRunner` specifies the class that contains the
 main method.
 
@@ -221,7 +221,7 @@
 Hi!
 {% endhighlight %}
 
-See the [build encyclopedia](build-encyclopedia.html#common.visibility) for more
+See the [build encyclopedia](be/common-definitions.html#common.visibility) for more
 visibility options.
 
 ## Deploying
@@ -261,7 +261,7 @@
 You can now create your own targets and compose them. Next, check out the
 [tutorial](/docs/tutorial/index.html) to learn how to build a server backend,
 Android app, and iOS app with Bazel. Also see the
-[build encyclopedia](build-encyclopedia.html) and
+[build encyclopedia](be/overview.html) and
 [user manual](bazel-user-manual.html) for more information.
 [Let us know](https://groups.google.com/forum/#!forum/bazel-discuss) if you have
 any questions!
diff --git a/site/docs/install.md b/site/docs/install.md
index 5652ed8..18c37f5 100644
--- a/site/docs/install.md
+++ b/site/docs/install.md
@@ -137,6 +137,7 @@
     zstyle ':completion:*' use-cache on
     zstyle ':completion:*' cache-path ~/.zsh/cache
     ```
+
 ## Compiling from source
 
 If you would like to build Bazel from source, clone the source from GitHub and
diff --git a/site/docs/test-encyclopedia.html b/site/docs/test-encyclopedia.html
index 2a285f4..d2501f1 100644
--- a/site/docs/test-encyclopedia.html
+++ b/site/docs/test-encyclopedia.html
@@ -153,7 +153,7 @@
 tests whose specified size is too big.</p>
 
 <p>Test sizes and timeouts are specified in the BUILD file according to the specification
-<a href="build-encyclopedia.html#test">here</a>.
+<a href="be/common-definitions.html#common-attributes-tests">here</a>.
 Any test that does not specify a recognized size will default to being a medium
 test.</p>
 
diff --git a/site/docs/tutorial/android-app.md b/site/docs/tutorial/android-app.md
index 9783d06..d58cf39 100644
--- a/site/docs/tutorial/android-app.md
+++ b/site/docs/tutorial/android-app.md
@@ -131,7 +131,7 @@
 
 Bazel provides two build rules, `android_library` and `android_binary`, that you
 can use to build an Android app. For this tutorial, you'll first use the
-[`android_library`](/docs/build-encyclopedia.html#android_library) rule to tell
+[`android_library`](/docs/be/android.html#android_library) rule to tell
 Bazel how to build an
 [Android library module](http://developer.android.com/tools/projects/index.html#LibraryProjects)
 from the app source code and resource files. Then you'll use the
@@ -156,7 +156,7 @@
 
 ### Add an android_binary rule
 
-The [`android_binary`](/docs/build-encyclopedia.html#android_binary) rule builds
+The [`android_binary`](/docs/be/android.html#android_binary) rule builds
 the Android application package (`.apk` file) for your app.
 
 Add the following to your build file:
diff --git a/site/docs/tutorial/backend-server.md b/site/docs/tutorial/backend-server.md
index 27d9158..1527d86 100644
--- a/site/docs/tutorial/backend-server.md
+++ b/site/docs/tutorial/backend-server.md
@@ -14,8 +14,7 @@
 *   Deploy to a local development server
 *   Deploy to Google App Engine
 
-Bazel provides a set of
-[App Engine build rules](https://github.com/bazelbuild/bazel/blob/master/tools/build_rules/appengine/README.md)
+Bazel provides a set of [App Engine build rules](/docs/be/appengine.html)
 written using the [Skylark](/docs/skylark/index.html) framework. You'll use
 these in the steps below to build the application.
 
@@ -60,7 +59,7 @@
 required App Engine SDK package from a remote server. This is optional. You
 can also download and install the SDK manually on your filesystem and reference
 it from that location as described in the
-[App Engine rule documentation](https://github.com/google/bazel/blob/master/tools/build_rules/appengine/README.md).
+[App Engine rule documentation](/docs/be/appengine.html).
 
 Add the following to your `WORKSPACE` file:
 
@@ -73,7 +72,7 @@
 )
 ```
 
-The [`new_http_archive`](/docs/build-encyclopedia.html#new_http_archive) rule
+The [`new_http_archive`](/docs/be/workspace.html#new_http_archive) rule
 instructs Bazel to download a remote archive file, uncompress it and add it to
 the virtual `external` package by combining the archive contents with
 the referenced `BUILD` file, here `appengine.BUILD`. You'll create this file
@@ -81,7 +80,7 @@
 
 ### Add bind rules
 
-You also need to add some [`bind`](docs/build-encyclopedia.html#bind) rules
+You also need to add some [`bind`](/docs/be/workspace.html#bind) rules
 to the file. These provide aliases to targets in the virtual `external` package
 so they can be located either either inside or outside the workspace without
 changing the App Engine build rules.
@@ -108,7 +107,7 @@
 ### Add maven_jar rules
 
 Finally, you need to add some
-[`maven_jar`](/docs/build-encyclopedia.html#maven_jar) rules to the file. These
+[`maven_jar`](/docs/be/workspace.html#maven_jar) rules to the file. These
 tell Bazel to download `.jar` files from the Maven repository and allow Bazel
 to use them as Java dependencies.
 
@@ -173,7 +172,7 @@
 )
 ```
 
-The [`java_import`](/docs/build-encyclopedia.html#java_import) rules tell
+The [`java_import`](/docs/be/java.html#java_import) rules tell
 Bazel how to use the precompiled SDK `.jar` files as libraries. These rules
 define the targets that you referenced in the `bind` rules in the `WORKSPACE`
 file above.
@@ -209,11 +208,11 @@
 )
 ```
 
-The [`java_binary`](/docs/build-encyclopedia.html#java_binary) tells Bazel
+The [`java_binary`](/docs/be/java.html#java_binary) tells Bazel
 how to build a Java `.jar` library for your application, plus a wrapper shell
 script that launches the application code from the specified main class. Here,
 we're using this rule instead of the
-[`java_library`](/docs/build-encyclopedia.html#java_library) because we need
+[`java_library`](/docs/be/java.html#java_library) because we need
 the `.jar` file to contain all the dependencies required to build the final
 App Engine `.war` file. For this reason, we specify a bogus class name
 for the `main_class` attribute.
@@ -236,7 +235,7 @@
 )
 ```
 
-The [`appengine_war`](https://github.com/google/bazel/blob/master/tools/build_rules/appengine/README.md)
+The [`appengine_war`](/docs/be/appengine.html#appengine_war)
 rule builds the final App Engine `war` file from the library `.jar` file and web
 application metadata files in the `webapp` directory.
 
diff --git a/site/docs/tutorial/ios-app.md b/site/docs/tutorial/ios-app.md
index fd99f6b..9faf711 100644
--- a/site/docs/tutorial/ios-app.md
+++ b/site/docs/tutorial/ios-app.md
@@ -38,7 +38,7 @@
 
 Bazel provides several build rules that you can use to build an app for the
 iOS platform. For this tutorial, you'll first use the
-[`objc_library`](/docs/build-encyclopedia.html#objc_library) rule to tell Bazel
+[`objc_library`](/docs/be/objective-c.html#objc_library) rule to tell Bazel
 how to build an
 [static library](https://developer.apple.com/library/ios/technotes/iOSStaticLibraries/Introduction.html)
 from the app source code and Xib files. Then you'll use the
@@ -65,7 +65,7 @@
 
 ## Add an objc_binary rule
 
-The [`objc_binary`](/docs/build-encyclopedia.html#objc_binary) rule creates a
+The [`objc_binary`](/docs/be/objective-c.html#objc_binary) rule creates a
 binary to be bundled in the application.
 
 Add the following to your `BUILD` file:
@@ -87,7 +87,7 @@
 
 ## Add an ios_application rule
 
-The [`ios_application`](/docs/build-encyclopedia.html#ios_application) rule
+The [`ios_application`](/docs/be/objective-c.html#ios_application) rule
 creates the bundled `.ipa` archive file for the application and also generates
 an Xcode project file.
 
diff --git a/site/faq.md b/site/faq.md
index 1339444..6fdb191 100644
--- a/site/faq.md
+++ b/site/faq.md
@@ -386,9 +386,9 @@
 We have an extension mechanism called Skylark that allows you to add new rules
 without recompiling Bazel.
 
-For documentation: see [here](docs/skylark/index.html). We have support for
+For documentation: see [here](/docs/skylark/index.html). We have support for
 several languages that use that extension mechanism, see our
-[build encyclopedia](http://bazel.io/docs/build-encyclopedia.html) for the full
+[build encyclopedia](/docs/be/overview.html) for the full
 list of supported languages.
 
 I need more functionality. Can I add rules that are compiled into Bazel?
diff --git a/site/roadmap.md b/site/roadmap.md
index 0a61777..574ef60 100644
--- a/site/roadmap.md
+++ b/site/roadmap.md
@@ -61,15 +61,15 @@
       <td rowspan="9"><b>2015&#8209;03</b></td>
       <td>Linux &amp; OS X Support</td>
     </tr>
-    <tr><td>C++ (<a href="http://bazel.io/docs/build-encyclopedia.html#cc_binary">build</a> and <a href="http://bazel.io/docs/build-encyclopedia.html#cc_test">test</a>)</td></tr>
-    <tr><td>Java (<a href="http://bazel.io/docs/build-encyclopedia.html#java_binary">build</a> and <a href="http://bazel.io/docs/build-encyclopedia.html#java_test">test</a>)</td></tr>
-    <tr><td>Objective-C for iOS (<a href="http://bazel.io/docs/build-encyclopedia.html#objc_binary">build</a>)</td></tr>
-    <tr><td>Python (<a href="http://bazel.io/docs/build-encyclopedia.html#py_binary">build</a>)</td></tr>
-    <tr><td>iOS applications (<a href="http://bazel.io/docs/build-encyclopedia.html#ios_application">build</a>)</td></tr>
+    <tr><td>C++ (<a href="http://bazel.io/docs/be/c-cpp.html#cc_binary">build</a> and <a href="http://bazel.io/docs/be/c-cpp.html#cc_test">test</a>)</td></tr>
+    <tr><td>Java (<a href="http://bazel.io/docs/be/java.html#java_binary">build</a> and <a href="http://bazel.io/docs/be/java.html#java_test">test</a>)</td></tr>
+    <tr><td>Objective-C for iOS (<a href="http://bazel.io/docs/be/objective-c.html#objc_binary">build</a>)</td></tr>
+    <tr><td>Python (<a href="http://bazel.io/docs/be/python.html#py_binary">build</a>)</td></tr>
+    <tr><td>iOS applications (<a href="http://bazel.io/docs/be/objective-c.html#ios_application">build</a>)</td></tr>
     <tr><td>Skylark extension mechanism (<a href="http://bazel.io/docs/skylark/index.html">build</a>)</td></tr>
     <tr><td>Basic test suite on GitHub</td></tr>
-    <tr><td>Support for fetching dependencies from <a href="http://bazel.io/docs/build-encyclopedia.html#maven_jar">Maven repositories</a>
-        and <a href="http://bazel.io/docs/build-encyclopedia.html#http_archive">web servers</a></td></tr>
+    <tr><td>Support for fetching dependencies from <a href="http://bazel.io/docs/be/workspace.html#maven_jar">Maven repositories</a>
+        and <a href="http://bazel.io/docs/be/workspace.html#http_archive">web servers</a></td></tr>
     <tr>
       <td rowspan="23"><b><a name="beta"></a>Beta</b></td>
       <td rowspan="9"><b>0.1</b></td>
@@ -78,12 +78,12 @@
     </tr>
     <tr><td>P0. Public <a href="http://ci.bazel.io">continuous integration system</a></td></tr>
     <tr><td>P0. Support for <a href="http://bazel.io/docs/external.html">fetching transitive dependencies from Maven Central</a></td></tr>
-    <tr><td>P0. Android application (<a href="http://bazel.io/docs/build-encyclopedia.html#android_binary">build</a>
+    <tr><td>P0. Android application (<a href="http://bazel.io/docs/be/android.html#android_binary">build</a>
         and <a href="http://bazel.io/docs/bazel-user-manual.html#mobile-install">install</a>)</td></tr>
     <tr><td>P1. Support for <a href="http://bazel.io/docs/external.html">prefetching and caching remote dependencies</a></td></tr>
-    <tr><td>P1. Docker (<a href="https://github.com/google/bazel/blob/master/tools/build_defs/docker/README.md">build and load</a>)</td></tr>
+    <tr><td>P1. Docker (<a href="http://bazel.io/docs/be/docker.html">build and load</a>)</td></tr>
     <tr><td>P2. <a href="http://bazel.io/docs/bazel-user-manual.html#sandboxing">Sandboxing of actions for Linux</a></td></tr>
-    <tr><td>P2. AppEngine (<a href="https://github.com/google/bazel/blob/master/tools/build_rules/appengine/README.md">build and load</a>)</td></tr>
+    <tr><td>P2. AppEngine (<a href="http://bazel.io/docs/be/appengine.html">build and load</a>)</td></tr>
     <tr><td>P2. <a href="http://bazel.io/blog/2015/07/29/dashboard-dogfood.html">Test result dashboard</a></tr></td>
     <tr>
       <td rowspan="3"><b>0.2</b></td>
diff --git a/src/main/java/com/google/devtools/build/docgen/DocgenConsts.java b/src/main/java/com/google/devtools/build/docgen/DocgenConsts.java
index 31a63ad..10b81b7 100644
--- a/src/main/java/com/google/devtools/build/docgen/DocgenConsts.java
+++ b/src/main/java/com/google/devtools/build/docgen/DocgenConsts.java
@@ -80,9 +80,7 @@
       " To edit, submit changes to the Blaze source code.",
       "-->",
       "",
-      "<!-- Generated by //java/com/google/devtools/build/docgen:build-encyclopedia.html -->"));
-
-  public static final String BUILD_ENCYCLOPEDIA_NAME = "build-encyclopedia.html";
+      "<!-- Generated by //java/com/google/devtools/build/docgen:build-encyclopedia.zip -->"));
 
   public static final FileTypeSet JAVA_SOURCE_FILE_SUFFIX = FileTypeSet.of(FileType.of(".java"));
 
diff --git a/tools/build_defs/groovy/README.md b/tools/build_defs/groovy/README.md
index f8e9b01..ad1763f 100644
--- a/tools/build_defs/groovy/README.md
+++ b/tools/build_defs/groovy/README.md
@@ -174,7 +174,7 @@
     <tr>
       <td><code>**kwargs</code></td>
       <td>
-        <code>see <a href="http://bazel.io/docs/build-encyclopedia.html#java_import">java_binary</a></code>
+        <code>see <a href="http://bazel.io/docs/be/java.html#java_import">java_binary</a></code>
         <p>
           The other arguments of this rule will be passed to the `java_import`
           that wraps the groovy library.
@@ -233,7 +233,7 @@
     <tr>
       <td><code>**kwargs</code></td>
       <td>
-        <code>see <a href="http://bazel.io/docs/build-encyclopedia.html#java_import">java_binary</a></code>
+        <code>see <a href="http://bazel.io/docs/be/java.html#java_import">java_binary</a></code>
         <p>
           The other arguments of this rule will be passed to the `java_import`
           that wraps the groovy library.
@@ -305,7 +305,7 @@
     <tr>
       <td><code>**kwargs</code></td>
       <td>
-        <code>see <a href="http://bazel.io/docs/build-encyclopedia.html#java_binary">java_binary</a></code>
+        <code>see <a href="http://bazel.io/docs/be/java.html#java_binary">java_binary</a></code>
         <p>
           The other arguments of this rule will be passed to the `java_binary`
           underlying the `groovy_binary`.
diff --git a/tools/build_rules/appengine/README.md b/tools/build_rules/appengine/README.md
index f8a7f4d..8c806f1 100644
--- a/tools/build_rules/appengine/README.md
+++ b/tools/build_rules/appengine/README.md
@@ -169,7 +169,7 @@
   </tbody>
 </table>
 
-<a name="java_war">
+<a name="java_war"></a>
 ## java_war
 
 ```
@@ -213,7 +213,7 @@
     <tr>
       <td><code>**kwargs</code></td>
       <td>
-        <code>see <a href="http://bazel.io/docs/build-encyclopedia.html#java_library">java_library</a></code>
+        <code>see <a href="http://bazel.io/docs/be/java.html#java_library">java_library</a></code>
         <p>
           The other arguments of this rule will be passed to build a `java_library`
           that will be passed in the `jar` arguments of a
