diff --git a/Documentation/cmd-query.txt b/Documentation/cmd-query.txt
index 253bed1..2ad3b7a4 100644
--- a/Documentation/cmd-query.txt
+++ b/Documentation/cmd-query.txt
@@ -124,7 +124,7 @@
 ------
 The JSON messages consist of nested objects referencing the
 link:json.html#change[change],
-link:json.html#patchset[patchset],
+link:json.html#patchSet[patchset],
 link:json.html#[account]
 involved, and other attributes as appropriate.
 
diff --git a/Documentation/cmd-stream-events.txt b/Documentation/cmd-stream-events.txt
index 0fb27cc..a8cf3b0 100644
--- a/Documentation/cmd-stream-events.txt
+++ b/Documentation/cmd-stream-events.txt
@@ -67,7 +67,7 @@
 
 change:: link:json.html#change[change attribute]
 
-patchset:: link:json.html#patchset[patchset attribute]
+patchset:: link:json.html#patchSet[patchset attribute]
 
 uploader:: link:json.html#account[account attribute]
 
diff --git a/ReleaseNotes/index.txt b/ReleaseNotes/index.txt
index 2e4865f..452057c 100644
--- a/ReleaseNotes/index.txt
+++ b/ReleaseNotes/index.txt
@@ -1,6 +1,11 @@
 Gerrit Code Review - Release Notes
 ==================================
 
+[[2_5]]
+Version 2.5.x
+-------------
+* link:ReleaseNotes-2.5.html[2.5]
+
 [[2_4]]
 Version 2.4.x
 -------------
diff --git a/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/AdminConstants.java b/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/AdminConstants.java
index a085ce5..9e65836 100644
--- a/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/AdminConstants.java
+++ b/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/AdminConstants.java
@@ -50,6 +50,7 @@
 
   String buttonBrowseProjects();
   String projects();
+  String projectRepoBrowser();
   String headingGroupUUID();
   String headingOwner();
   String headingDescription();
diff --git a/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/AdminConstants.properties b/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/AdminConstants.properties
index 406f3d3..0743fbd 100644
--- a/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/AdminConstants.properties
+++ b/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/AdminConstants.properties
@@ -19,6 +19,7 @@
 checkBoxPermissionsOnly = Only serve as parent for other projects
 buttonBrowseProjects = Browse
 projects = All projects
+projectRepoBrowser = Repository Browser
 useContentMerge = Automatically resolve conflicts
 useContributorAgreements = Require a valid contributor agreement to upload
 useSignedOffBy = Require <a href="http://gerrit.googlecode.com/svn/documentation/2.0/user-signedoffby.html#Signed-off-by" target="_blank"><code>Signed-off-by</code></a> in commit message
diff --git a/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/ProjectListScreen.java b/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/ProjectListScreen.java
index d911c93..9125622 100644
--- a/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/ProjectListScreen.java
+++ b/gerrit-gwtui/src/main/java/com/google/gerrit/client/admin/ProjectListScreen.java
@@ -15,6 +15,8 @@
 package com.google.gerrit.client.admin;
 
 import com.google.gerrit.client.Dispatcher;
+import com.google.gerrit.client.Gerrit;
+import com.google.gerrit.client.GitwebLink;
 import com.google.gerrit.client.projects.ProjectInfo;
 import com.google.gerrit.client.projects.ProjectMap;
 import com.google.gerrit.client.rpc.ScreenLoadCallback;
@@ -23,6 +25,7 @@
 import com.google.gerrit.client.ui.Screen;
 import com.google.gerrit.common.PageLinks;
 import com.google.gwt.user.client.History;
+import com.google.gwt.user.client.ui.Anchor;
 
 public class ProjectListScreen extends Screen {
   private ProjectsTable projects;
@@ -46,6 +49,16 @@
 
     projects = new ProjectsTable() {
       @Override
+      protected void initColumnHeaders() {
+        super.initColumnHeaders();
+        if (Gerrit.getGitwebLink() != null) {
+          table.setText(0, 3, Util.C.projectRepoBrowser());
+          table.getFlexCellFormatter().
+            addStyleName(0, 3, Gerrit.RESOURCES.css().dataHeader());
+        }
+      }
+
+      @Override
       protected void onOpenRow(final int row) {
         History.newItem(link(getRowItem(row)));
       }
@@ -55,9 +68,23 @@
       }
 
       @Override
+      protected void insert(int row, ProjectInfo k) {
+        super.insert(row, k);
+        if (Gerrit.getGitwebLink() != null) {
+          table.getFlexCellFormatter().
+            addStyleName(row, 3, Gerrit.RESOURCES.css().dataCell());
+        }
+      }
+
+      @Override
       protected void populate(final int row, final ProjectInfo k) {
         table.setWidget(row, 1, new Hyperlink(k.name(), link(k)));
         table.setText(row, 2, k.description());
+        GitwebLink l = Gerrit.getGitwebLink();
+        if (l != null) {
+          table.setWidget(row, 3, new Anchor(l.getLinkName(), false, l.toProject(k
+              .name_key())));
+        }
 
         setRowItem(row, k);
       }
diff --git a/gerrit-gwtui/src/main/java/com/google/gerrit/client/ui/ProjectsTable.java b/gerrit-gwtui/src/main/java/com/google/gerrit/client/ui/ProjectsTable.java
index 50dab9f..0cbe194 100644
--- a/gerrit-gwtui/src/main/java/com/google/gerrit/client/ui/ProjectsTable.java
+++ b/gerrit-gwtui/src/main/java/com/google/gerrit/client/ui/ProjectsTable.java
@@ -35,7 +35,10 @@
     keysNavigation.add(new OpenKeyCommand(0, 'o', Util.C.projectListOpen()));
     keysNavigation.add(new OpenKeyCommand(0, KeyCodes.KEY_ENTER,
                                                   Util.C.projectListOpen()));
+    initColumnHeaders();
+  }
 
+  protected void initColumnHeaders() {
     table.setText(0, 1, Util.C.projectName());
     table.setText(0, 2, Util.C.projectDescription());
 
diff --git a/gerrit-httpd/src/main/java/com/google/gerrit/httpd/gitweb/GitWebServlet.java b/gerrit-httpd/src/main/java/com/google/gerrit/httpd/gitweb/GitWebServlet.java
index fb04226..6c37e43 100644
--- a/gerrit-httpd/src/main/java/com/google/gerrit/httpd/gitweb/GitWebServlet.java
+++ b/gerrit-httpd/src/main/java/com/google/gerrit/httpd/gitweb/GitWebServlet.java
@@ -370,7 +370,7 @@
     final ProjectControl project;
     try {
       project = projectControl.validateFor(nameKey);
-      if (!project.allRefsAreVisible()) {
+      if (!project.allRefsAreVisible() && !project.isOwner()) {
          // Pretend the project doesn't exist
         throw new NoSuchProjectException(nameKey);
       }
diff --git a/gerrit-server/src/main/java/com/google/gerrit/server/plugins/ListPlugins.java b/gerrit-server/src/main/java/com/google/gerrit/server/plugins/ListPlugins.java
index b87af89..3f7bc97 100644
--- a/gerrit-server/src/main/java/com/google/gerrit/server/plugins/ListPlugins.java
+++ b/gerrit-server/src/main/java/com/google/gerrit/server/plugins/ListPlugins.java
@@ -94,7 +94,7 @@
       } else {
         stdout.format("%-30s %-10s %-8s\n", p.getName(),
             Strings.nullToEmpty(info.version),
-            p.isDisabled() ? "DISABLED" : "");
+            p.isDisabled() ? "DISABLED" : "ENABLED");
       }
     }
 
