diff --git a/RELEASE-NOTES.txt b/RELEASE-NOTES.txt
index 3dc65a0..58f3b01 100644
--- a/RELEASE-NOTES.txt
+++ b/RELEASE-NOTES.txt
@@ -5,15 +5,81 @@
 lzma, xz, Snappy, traditional Unix Compress, DEFLATE and ar, cpio,
 jar, tar, zip, dump, 7z, arj.
 
-Release 1.11 (not yet released)
+Release 1.11
 ------------
 
-Changes
-o Allow byte-for-byte replication of Zip entries
+New features:
+o TarArchiveInputStream now supports reading global PAX headers.
+  Issue: COMPRESS-347.
+o The PAX headers for sparse entries written by star are now
+  applied.
+  Issue: COMPRESS-346.
+o GNU sparse files using one of the PAX formats are now
+  detected, but cannot be extracted.
+  Issue: COMPRESS-345.
+o New method SevenZFile.getEntries can be used to list the
+  contents of a 7z archive.
+  Issue: COMPRESS-341.
+o When using Zip64Mode.Always also use ZIP64 extensions inside
+  the central directory.
+  GitHub Pull Request #10 Thanks to Matt Hovey.
+o ZipFile.getRawInputStream() is now part of the public API
+  Issue: COMPRESS-323.
+o Allow byte-for-byte replication of Zip entries.
+  GitHub Pull Request #6. Thanks to Jason van Zyl.
 o TarArchiveEntry's preserveLeadingSlashes is now a property and used
   on later calls to setName, too.
   This behavior is a breaking change.
-  Issue: COMPRESS-328
+  Issue: COMPRESS-328.
+o Added read-only support for bzip2 compression used inside of
+  ZIP archives.
+  GitHub Pull Request #4. Thanks to Sören Glimm.
+
+Fixed Bugs:
+o ArArchiveInputStream can now read GNU extended names that are
+  terminated with a NUL byte rather than a linefeed.
+  Issue: COMPRESS-344.
+o Native Memory Leak in Sevenz-DeflateDecoder.
+  Issue: COMPRESS-343. Thanks to Rene Preissel.
+o SevenZFile will now only try to drain an entry's content when
+  moving on to the next entry if data is read from the next
+  entry. This should improve performance for applications that
+  try to skip over entries.
+  Issue: COMPRESS-340. Thanks to Dawid Weiss.
+o file names of tar archives using the xstar format are now
+  parsed properly.
+  Issue: COMPRESS-336.
+o checksums of tars that pad the checksum field to the left are
+  now calculated properly.
+  Issue: COMPRESS-335.
+o ArArchiveInputStream failed to read past the first entry when
+  BSD long names have been used.
+  Issue: COMPRESS-334. Thanks to Jeremy Gustie.
+o Added buffering for random access which speeds up 7Z support.
+  Issue: COMPRESS-333. Thanks to Dawid Weiss.
+o The checksum validation of TararchiveEntry is now as strict as
+  the validation of GNU tar, which eliminates a few cases of
+  false positives of ArchiveStreamFactory.
+  This behavior is a breaking change since the check has become
+  more strict but any archive that fails the checksum test now
+  would also fail it when extracted with other tools and must be
+  considered an invalid archive.
+  Issue: COMPRESS-331.
+o SnappyCompressorInputStream and
+  FramedSnappyCompressorInputStream returned 0 at the end of the
+  stream under certain circumstances.
+  Issue: COMPRESS-332.
+o Adjusted unit test to updates in Java8 and later that change
+  the logic of ZipEntry#getTime.
+  Issue: COMPRESS-326.
+o TarArchiveOutputStream will now recognize GNU long name and
+  link entries even if the special entry has a different name
+  than GNU tar uses itself.  This seems to be the case for
+  archives created by star.
+  Issue: COMPRESS-324.
+o ArrayIndexOutOfBoundsException when InfoZIP type 7875 extra
+  fields are read from the central directory.
+  Issue: COMPRESS-321.
 
 Release 1.10
 ------------
diff --git a/pom.xml b/pom.xml
index 8cba58e..4551aaa 100644
--- a/pom.xml
+++ b/pom.xml
@@ -25,7 +25,7 @@
 
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-compress</artifactId>
-  <version>1.11-SNAPSHOT</version>
+  <version>1.11</version>
   <name>Apache Commons Compress</name>
   <url>http://commons.apache.org/proper/commons-compress/</url>
   <!-- The description is not indented to make it look better in the release notes -->
diff --git a/src/site/site.xml b/src/site/site.xml
index fb272fe..626d7d3 100644
--- a/src/site/site.xml
+++ b/src/site/site.xml
@@ -35,6 +35,7 @@
       <item name="Download"    href="/download_compress.cgi"/>
       <item name="Security Reports"    href="/security-reports.html"/>
       <item name="Wiki"        href="http://wiki.apache.org/commons/Compress"/>
+      <item name="Javadoc 1.11" href="javadocs/api-1.11/index.html"/>
       <item name="Javadoc 1.10" href="javadocs/api-1.10/index.html"/>
       <item name="Javadoc 1.9" href="javadocs/api-1.9/index.html"/>
       <item name="Javadoc 1.8.1" href="javadocs/api-1.8.1/index.html"/>
diff --git a/src/site/xdoc/download_compress.xml b/src/site/xdoc/download_compress.xml
index c8cfa4d..4a3b23b 100644
--- a/src/site/xdoc/download_compress.xml
+++ b/src/site/xdoc/download_compress.xml
@@ -95,32 +95,32 @@
       </p>
     </subsection>
     </section>
-    <section name="Apache Commons Compress 1.10 ">
+    <section name="Apache Commons Compress 1.11 ">
       <subsection name="Binaries">
         <table>
           <tr>
-              <td><a href="[preferred]/commons/compress/binaries/commons-compress-1.10-bin.tar.gz">commons-compress-1.10-bin.tar.gz</a></td>
-              <td><a href="http://www.apache.org/dist/commons/compress/binaries/commons-compress-1.10-bin.tar.gz.md5">md5</a></td>
-              <td><a href="http://www.apache.org/dist/commons/compress/binaries/commons-compress-1.10-bin.tar.gz.asc">pgp</a></td>
+              <td><a href="[preferred]/commons/compress/binaries/commons-compress-1.11-bin.tar.gz">commons-compress-1.11-bin.tar.gz</a></td>
+              <td><a href="https://www.apache.org/dist/commons/compress/binaries/commons-compress-1.11-bin.tar.gz.md5">md5</a></td>
+              <td><a href="https://www.apache.org/dist/commons/compress/binaries/commons-compress-1.11-bin.tar.gz.asc">pgp</a></td>
           </tr>
           <tr>
-              <td><a href="[preferred]/commons/compress/binaries/commons-compress-1.10-bin.zip">commons-compress-1.10-bin.zip</a></td>
-              <td><a href="http://www.apache.org/dist/commons/compress/binaries/commons-compress-1.10-bin.zip.md5">md5</a></td>
-              <td><a href="http://www.apache.org/dist/commons/compress/binaries/commons-compress-1.10-bin.zip.asc">pgp</a></td>
+              <td><a href="[preferred]/commons/compress/binaries/commons-compress-1.11-bin.zip">commons-compress-1.11-bin.zip</a></td>
+              <td><a href="https://www.apache.org/dist/commons/compress/binaries/commons-compress-1.11-bin.zip.md5">md5</a></td>
+              <td><a href="https://www.apache.org/dist/commons/compress/binaries/commons-compress-1.11-bin.zip.asc">pgp</a></td>
           </tr>
         </table>
       </subsection>
       <subsection name="Source">
         <table>
           <tr>
-              <td><a href="[preferred]/commons/compress/source/commons-compress-1.10-src.tar.gz">commons-compress-1.10-src.tar.gz</a></td>
-              <td><a href="http://www.apache.org/dist/commons/compress/source/commons-compress-1.10-src.tar.gz.md5">md5</a></td>
-              <td><a href="http://www.apache.org/dist/commons/compress/source/commons-compress-1.10-src.tar.gz.asc">pgp</a></td>
+              <td><a href="[preferred]/commons/compress/source/commons-compress-1.11-src.tar.gz">commons-compress-1.11-src.tar.gz</a></td>
+              <td><a href="https://www.apache.org/dist/commons/compress/source/commons-compress-1.11-src.tar.gz.md5">md5</a></td>
+              <td><a href="https://www.apache.org/dist/commons/compress/source/commons-compress-1.11-src.tar.gz.asc">pgp</a></td>
           </tr>
           <tr>
-              <td><a href="[preferred]/commons/compress/source/commons-compress-1.10-src.zip">commons-compress-1.10-src.zip</a></td>
-              <td><a href="http://www.apache.org/dist/commons/compress/source/commons-compress-1.10-src.zip.md5">md5</a></td>
-              <td><a href="http://www.apache.org/dist/commons/compress/source/commons-compress-1.10-src.zip.asc">pgp</a></td>
+              <td><a href="[preferred]/commons/compress/source/commons-compress-1.11-src.zip">commons-compress-1.11-src.zip</a></td>
+              <td><a href="https://www.apache.org/dist/commons/compress/source/commons-compress-1.11-src.zip.md5">md5</a></td>
+              <td><a href="https://www.apache.org/dist/commons/compress/source/commons-compress-1.11-src.zip.asc">pgp</a></td>
           </tr>
         </table>
       </subsection>
diff --git a/src/site/xdoc/index.xml b/src/site/xdoc/index.xml
index aded934..3a5bfce 100644
--- a/src/site/xdoc/index.xml
+++ b/src/site/xdoc/index.xml
@@ -51,33 +51,26 @@
         </section>
 
         <section name="Status">
-          <p>The current release is 1.10 and requires Java 5.</p>
+          <p>The current release is 1.11 and requires Java 5.</p>
 
           <p>Below we highlight some new features, for a full list
           of changes see the <a href="changes-report.html">Changes
           Report</a>.</p>
 
-          <subsection name="What's new in 1.10?">
-            <ul>
-              <li>The old
-              <code>org.apache.commons.compress.compressors.z._internal_</code>
-              now is
-              <code>org.apache.commons.compress.compressors.lzw</code>
-              and the code is now an official part of Commons
-              Compress' API.</li>
-              <li>Added support for parallel ZIP compression.</li>
-              <li>Added support for raw transfer of entries from one ZIP file to another without uncompress/compress.</li>
-              <li>Performance improvements for creating ZIP files with lots of small entries.</li>
-              <li>Added auto-detection for LZMA.</li>
-            </ul>
-          </subsection>
-
-          <subsection name="What's coming in 1.11?">
+          <subsection name="What's new in 1.11?">
             <ul>
               <li>Added read-only support for BZIP2 compression used
               inside of ZIP archives.</li>
+              <li>Speed improvements in <code>SevenZFile</code></li>
+              <li>Various fixes and improvements for tar, ar, snappy
+              and zip.</li>
             </ul>
           </subsection>
+
+          <!--subsection name="What's coming in 1.12?">
+            <ul>
+            </ul>
+          </subsection-->
         </section>
 
         <section name="Documentation">
@@ -95,14 +88,14 @@
             by the <code>java.util.jar</code> package of the Java
             class library.  XZ and lzma support is provided by the public
             domain <a href="http://tukaani.org/xz/java.html">XZ for
-            Java</a> library.  As of Commons Compress 1.10 support for
+            Java</a> library.  As of Commons Compress 1.11 support for
             the lzma, Z and Snappy formats is read-only.</p>
 
           <p>The ar, arj, cpio, dump, tar, 7z and zip formats are supported as
             archivers where the <a href="zip.html">zip</a>
             implementation provides capabilities that go beyond the
             features found in java.util.zip.  As of Commons Compress
-            1.10 support for the dump and arj formats is
+            1.11 support for the dump and arj formats is
             read-only - 7z can read most compressed and encrypted
             archives but only write unencrypted ones.  LZMA(2) support
             in 7z requires <a href="http://tukaani.org/xz/java.html">XZ for
