pkg.go.dev website, Go packages, Go modules, package search, documentation browser, standard library docs, dependency discovery, module versions, import paths, open-source package site, and WHOIS domain data

pkg.go.dev

pkg.go.dev is the official Go package discovery and documentation website, helping developers search packages, read docs, inspect modules, and copy import paths.

Core purpose

pkg.go.dev is the Go package search and documentation site for modules, packages, symbols, import paths, and standard library reference pages.

Official website

pkg.go.dev is linked from the Go project's official navigation as the Packages destination.

go.dev registered

February 13, 2019

The Go project logo used as the brand image for the pkg.go.dev package discovery and documentation website page.View Go logo on pkg.go.dev

What pkg.go.dev is

pkg.go.dev official site is the Go project's package search and documentation website. Developers use it to search for Go packages, browse standard library documentation, inspect module pages, find symbols, and copy import paths for use in their own code. The site is not a centralized upload registry in the same style as some language package catalogs. Go modules are commonly published from source repositories, while pkg.go.dev gives the ecosystem a searchable documentation and discovery layer.

Search and documentation

The homepage highlights searches for package names, commands, symbols, and filters inside packages. A user can search for a broad term, jump to a standard library package, or look for a specific symbol such as a function, type, or interface. That makes the site useful at two speeds: quick lookup while coding, and slower evaluation when choosing a dependency. A package page can show documentation, versions, module paths, repository links, license signals, and import information.

Modules, packages, and import paths

Go dependency management is built around modules that contain packages. The Go documentation explains that developers can search pkg.go.dev for useful packages, copy a package path, import it in code, and then use Go tools to add and manage the dependency. This model keeps source distribution decentralized while still giving developers a shared place to discover and read public API documentation.

Standard library and third-party code

pkg.go.dev serves both the Go standard library and third-party packages. Standard library pages are reference material for everyday Go programming, while third-party module pages help developers evaluate libraries hosted across public repositories. The combination matters because Go programmers often move between built-in packages and external modules while solving one problem. A single documentation browser lowers that friction.

Open-source package site

The Go project announced that pkg.go.dev is open source, and the public project is maintained in the `golang/pkgsite` repository. That gives contributors and users a place to report issues, discuss search and navigation improvements, and understand how the package site works. Open development is especially important for ecosystem infrastructure. Search quality, license detection, documentation rendering, and navigation all shape how developers choose dependencies.

Who uses pkg.go.dev

pkg.go.dev is used by Go developers, module authors, library maintainers, teams evaluating dependencies, students learning the standard library, security reviewers checking package metadata, and open-source contributors following package documentation or source links.

Why it matters

A package ecosystem needs more than downloadable code. It needs readable documentation, stable import paths, discoverable versions, and enough context for users to make dependency decisions. pkg.go.dev provides that public reading layer for Go. The site also reinforces Go's module workflow. It connects documentation in the browser with local commands such as importing a package and using Go tools to add, upgrade, or tidy dependencies.

WHOIS domain data

Data pulled: May 24, 2026View current WHOIS record

Website host: pkg.go.dev
Registrable domain: go.dev
WHOIS source note: pkg.go.dev is a subdomain, so Who.is domain registration data is shown for go.dev. The Who.is WHOIS lookup reported no traditional WHOIS data; the visible fields below are from the Who.is RDAP view.
IP address: 216.239.32.21
Registrar: Markmonitor Inc.
Registrar handle: 292
Contact URI: https://www.markmonitor.com/contact-us/
Created: February 13, 2019
Updated: January 12, 2026
RDAP database updated: May 20, 2026
Expires: February 13, 2027
Nameservers: ns-cloud-e1.googledomains.com (216.239.32.110); ns-cloud-e2.googledomains.com (216.239.34.110); ns-cloud-e3.googledomains.com (216.239.36.110); ns-cloud-e4.googledomains.com (216.239.38.110)
Domain status: client delete prohibited, client transfer prohibited, client update prohibited
Contact privacy: The visible Who.is RDAP summary shows a domain contact URI at https://domains.markmonitor.com/whois/contact/go.dev; registrant personal details are not displayed.

Key concepts

ModuleA versioned collection of Go packages managed with a module path and a go.mod file.
PackageA directory of Go source files compiled together and imported by path.
Import pathThe string used in Go code to identify the package being imported.
Symbol searchA way to find functions, types, methods, constants, and variables across package documentation.

Common workflows

Search pkg.go.dev for a package, symbol, or command.
Read package documentation and examples before importing a dependency.
Copy an import path from a package page into Go source code.
Follow module, repository, version, license, or documentation links when evaluating a package.

Common misconceptions

pkg.go.dev is not where most Go authors manually upload packages; Go modules are typically published through source repositories.
A package appearing on pkg.go.dev does not guarantee that it is maintained, secure, or suitable for production.
A module and a package are related but not identical; one module can contain multiple packages.

Open questions

How can package documentation sites show maintenance and security context without overwhelming readers?
What search signals best help developers choose between similarly named Go packages?
How should decentralized module ecosystems balance repository freedom with centralized discovery?