{{define "Head"}}<title>GoDoc</title>
{{/* <link type="application/opensearchdescription+xml" rel="search" href="/-/opensearch.xml?v={{fileHash "templates/opensearch.xml"}}"/> */}}{{end}}

{{define "Body"}}
<div class="jumbotron">
    <h2>Search for Go Packages</h2>
    {{template "SearchBox" ""}}
</div>

<p>GoDoc hosts documentation for <a href="https://golang.org/">Go</a> packages
on Bitbucket, GitHub, Google Project Hosting and Launchpad.  Read the <a
  href="/-/about">About Page</a> for information about adding packages to GoDoc
and more.

<div class="row">
  <div class="col-sm-6">
    {{with .Popular}}
      <h4>Popular Packages</h4>
      <ul class="list-unstyled">
        {{range .}}<li><a href="/{{.Path}}">{{.Path}}</a>{{end}}
      </ul>
    {{end}}
  </div>
  <div class="col-sm-6">
    <h4>More Packages</h4>
    <ul class="list-unstyled">
      <li><a href="/-/go">Go Standard Packages</a>
      <li><a href="/-/subrepo">Go Sub-repository Packages</a>
      <li><a href="https://golang.org/wiki/Projects">Projects @ go-wiki</a>
      <li><a href="https://github.com/search?o=desc&amp;q=language%3Ago&amp;s=stars&amp;type=Repositories">Most stars</a>, 
        <a href="https://github.com/search?o=desc&amp;q=language%3Ago&amp;s=forks&amp;type=Repositories">most forks</a>, 
        <a href="https://github.com/search?o=desc&amp;q=language%3Ago&amp;s=updated&amp;type=Repositories">recently updated</a> on GitHub
    </ul>
  </div>
</div>

{{end}}
