diff --git a/java/com/google/gitiles/HostIndexServlet.java b/java/com/google/gitiles/HostIndexServlet.java
index 8b8a252..6851688 100644
--- a/java/com/google/gitiles/HostIndexServlet.java
+++ b/java/com/google/gitiles/HostIndexServlet.java
@@ -17,12 +17,11 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Sets;
 import com.google.gitiles.GitilesRequestFailureException.FailureReason;
 import com.google.gson.reflect.TypeToken;
-import com.google.template.soy.data.SoyListData;
-import com.google.template.soy.data.SoyMapData;
 import com.google.template.soy.data.restricted.NullData;
 import java.io.IOException;
 import java.io.Writer;
@@ -66,12 +65,15 @@
     return descs;
   }
 
-  private SoyMapData toSoyMapData(
+  private Map<String, Object> toMapData(
       RepositoryDescription desc, @Nullable String prefix, GitilesView view) {
-    return new SoyMapData(
-        "name", stripPrefix(prefix, desc.name),
-        "description", Strings.nullToEmpty(desc.description),
-        "url", GitilesView.repositoryIndex().copyFrom(view).setRepositoryName(desc.name).toUrl());
+    return ImmutableMap.<String, Object>builder()
+        .put("name", stripPrefix(prefix, desc.name))
+        .put("description", Strings.nullToEmpty(desc.description))
+        .put(
+            "url",
+            GitilesView.repositoryIndex().copyFrom(view).setRepositoryName(desc.name).toUrl())
+        .build();
   }
 
   @Override
@@ -111,10 +113,10 @@
       return;
     }
 
-    SoyListData repos = new SoyListData();
+    ImmutableList.Builder<Map<String, Object>> repos = ImmutableList.builder();
     for (RepositoryDescription desc : descs.values()) {
       if (prefix == null || desc.name.startsWith(prefix)) {
-        repos.add(toSoyMapData(desc, prefix, view));
+        repos.add(toMapData(desc, prefix, view));
       }
     }
 
@@ -132,11 +134,11 @@
             "hostName",
             hostName,
             "breadcrumbs",
-            breadcrumbs != null ? new SoyListData(breadcrumbs) : NullData.INSTANCE,
+            breadcrumbs != null ? breadcrumbs : NullData.INSTANCE,
             "prefix",
             prefix != null ? prefix + '/' : "",
             "repositories",
-            repos));
+            repos.build()));
   }
 
   @Override
diff --git a/javatests/com/google/gitiles/HostIndexServletTest.java b/javatests/com/google/gitiles/HostIndexServletTest.java
index d8332d1..a79ee8c 100644
--- a/javatests/com/google/gitiles/HostIndexServletTest.java
+++ b/javatests/com/google/gitiles/HostIndexServletTest.java
@@ -18,9 +18,8 @@
 import static com.google.gitiles.TestGitilesUrls.URLS;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
+import com.google.common.collect.ImmutableList;
 import com.google.gson.reflect.TypeToken;
-import com.google.template.soy.data.SoyListData;
-import com.google.template.soy.data.SoyMapData;
 import com.google.template.soy.data.restricted.NullData;
 import java.util.Map;
 import javax.servlet.http.HttpServletResponse;
@@ -48,15 +47,16 @@
 
   @Test
   public void rootHtml() throws Exception {
-    Map<String, ?> data = buildData("/");
+    Map<String, Object> data = buildData("/");
     assertThat(data).containsEntry("hostName", URLS.getHostName(null));
     assertThat(data).containsEntry("breadcrumbs", NullData.INSTANCE);
     assertThat(data).containsEntry("prefix", "");
 
-    SoyListData repos = (SoyListData) data.get("repositories");
+    ImmutableList<Map<String, Object>> repos =
+        (ImmutableList<Map<String, Object>>) data.get("repositories");
     assertThat(repos).hasSize(1);
 
-    SoyMapData ent = (SoyMapData) repos.get(0);
+    Map<String, Object> ent = repos.get(0);
     assertThat(ent.get("name").toString()).isEqualTo(NAME);
     assertThat(ent.get("url").toString()).isEqualTo("/b/" + NAME + "/");
   }
@@ -67,13 +67,15 @@
     assertThat(data).containsEntry("hostName", URLS.getHostName(null) + "/foo");
     assertThat(data).containsEntry("prefix", "foo/");
 
-    SoyListData breadcrumbs = (SoyListData) data.get("breadcrumbs");
-    assertThat(breadcrumbs.length()).isEqualTo(2);
+    ImmutableList<Map<String, Object>> breadcrumbs =
+        (ImmutableList<Map<String, Object>>) data.get("breadcrumbs");
+    assertThat(breadcrumbs.size()).isEqualTo(2);
 
-    SoyListData repos = (SoyListData) data.get("repositories");
-    assertThat(repos.length()).isEqualTo(1);
+    ImmutableList<Map<String, Object>> repos =
+        (ImmutableList<Map<String, Object>>) data.get("repositories");
+    assertThat(repos.size()).isEqualTo(1);
 
-    SoyMapData ent = (SoyMapData) repos.get(0);
+    Map<String, Object> ent = repos.get(0);
     assertThat(ent.get("name").toString()).isEqualTo("bar/repo");
     assertThat(ent.get("url").toString()).isEqualTo("/b/" + NAME + "/");
   }
@@ -84,13 +86,15 @@
     assertThat(data).containsEntry("hostName", URLS.getHostName(null) + "/foo/bar");
     assertThat(data).containsEntry("prefix", "foo/bar/");
 
-    SoyListData breadcrumbs = (SoyListData) data.get("breadcrumbs");
-    assertThat(breadcrumbs.length()).isEqualTo(3);
+    ImmutableList<Map<String, Object>> breadcrumbs =
+        (ImmutableList<Map<String, Object>>) data.get("breadcrumbs");
+    assertThat(breadcrumbs.size()).isEqualTo(3);
 
-    SoyListData repos = (SoyListData) data.get("repositories");
-    assertThat(repos.length()).isEqualTo(1);
+    ImmutableList<Map<String, Object>> repos =
+        (ImmutableList<Map<String, Object>>) data.get("repositories");
+    assertThat(repos.size()).isEqualTo(1);
 
-    SoyMapData ent = (SoyMapData) repos.get(0);
+    Map<String, Object> ent = repos.get(0);
     assertThat(ent.get("name").toString()).isEqualTo("repo");
     assertThat(ent.get("url").toString()).isEqualTo("/b/" + NAME + "/");
   }
diff --git a/javatests/com/google/gitiles/ServletTest.java b/javatests/com/google/gitiles/ServletTest.java
index c642a79..df349f0 100644
--- a/javatests/com/google/gitiles/ServletTest.java
+++ b/javatests/com/google/gitiles/ServletTest.java
@@ -94,7 +94,7 @@
     return buildHtml(path, true);
   }
 
-  protected Map<String, ?> buildData(String path) throws Exception {
+  protected Map<String, Object> buildData(String path) throws Exception {
     // Render the page through Soy to ensure templates are valid, then return
     // the Soy data for introspection.
     FakeHttpServletRequest req = FakeHttpServletRequest.newRequest();
