x

Package fsnotify provides a platform-independent interface for file system notifications.

conformance implements the conformance test subprocess protocol as documented in conformance.proto.

Package descriptor provides functions for obtaining protocol buffer descriptors for generated Go types.

Package jsonpb provides marshaling and unmarshaling between protocol buffers and JSON.

Package proto converts data structures to and from the wire format of protocol buffers.

The code generator for the plugin for the Google protocol buffer compiler.

Package grpc outputs gRPC service descriptions in Go code.

Package plugin_go is a generated protocol buffer package.

Package ptypes contains code for interacting with well-known types.

Package gopherjspkg provides core GopherJS packages via a virtual filesystem.

Package natives provides native packages via a virtual filesystem.

Package js provides functions for interacting with native JavaScript APIs.

Package tests contains tests for GopherJS.

Package jsbuiltin provides minimal wrappers around some JavasScript built-in functions.

bindata converts any file into managable Go source code.

Package pty provides functions for working with Unix terminals.

The canvas package provides some a facility for managing independently updating objects inside a graphics window.

The apipe command pipes the contents of the current acme window through its argument shell command and updates them to the result by applying minimal changes.

Calc is a calculator designed to be run on the command line.

A "simple" program to display some text and let the user drag it around.

The pxargs command is a simpler version of xargs(1) that can execute commands in parallel.

rpcreader demonstrates using RPC to initiate file streaming over the same connection.

Share is a piece of demo code to illustrate the flexibility of the rpc and netchan packages.

The stackgraph command reads a Go stack trace (as produced by a Go panic) from its standard input and writes an SVG file suitable for viewing in a web browser on its standard output.

The timestamp command annotates lines read from standard input with the time that they were read.

The deepdiff package implements a version of reflect.DeepEquals that also returns an error message describing the first difference found.

Fix finds Go programs that use old APIs and rewrites them to use newer ones.

Godef prints the source location of definitions in Go programs.

The gosym command manipulates symbols in Go source code.

ulimit -n 30000

The deepcopy package implements deep copying of arbitrary data structures, making sure that self references and shared pointers are preserved.

The event package demonstrates use of the callback package to call Go functions from a non-Go-created thread.

Looper is an example package demonstrating use of the callback package.

Package ast declares the types used to represent syntax trees for Go packages.

A parser for Go source files.

Package printer implements printing of AST nodes.

Package scanner implements a scanner for Go source text.

The sym package provides a way to iterate over and change the symbols in Go source files.

This package defines constants representing the lexical tokens of the Go programming language and basic operations on tokens (printing, predicates).

Types infers source locations and types from Go expressions.

Package debug contains facilities for programs to debug themselves while they are running.

Timestamp recording (for debugging).

The stringfs package provides a way to recursively encode the data in a directory as a string, and to extract the contents later.

Package draw provides basic graphics and drawing primitives, in the style of the Plan 9 graphics library (see http://plan9.bell-labs.com/magic/man2html/2/draw) and the X Render extension.

This package implements an X11 backend for the exp/draw package.

The fakenet package provides a way to turn a regular io.ReadWriter into a net.Conn, including support for timeouts.

The p9 package g9provides the definitions and functions used to implement the 9P2000 protocol.

The srv package provides definitions and functions used to implement a 9P2000 file client.

The netchanrpc package makes it possible to run an RPC service over netchan.

The ncrpc package layers client-server and server-client RPC interfaces on top of netchan.

The parallel package provides a way of running functions concurrently while limiting the maximum number running at once.

The values package provides multiple-writer, multiple-listener access to changing values.

Package blackfriday is a Markdown processor.

Package agouti is a universal WebDriver client for Go.

Package api provides a generic, low-level WebDriver API client for Go.

Package matchers provides a set of Gomega-compatible matchers for use with the agouti package.

Package filter offers an http.FileSystem wrapper with the ability to keep or skip files.

Package vfstemplate offers html/template helpers that use http.FileSystem.

Package httputil implements HTTP utility functions for http.FileSystem.

Package vfspath implements utility routines for manipulating virtual file system paths.

Package union offers a simple http.FileSystem that can unify multiple filesystems at various mount points.

Package vfsutil implements some I/O utility functions for http.FileSystem.

Package cobra is a commander providing a simple interface to create powerful modern CLI interfaces.

Package pflag is a drop-in replacement for Go's flag package, implementing POSIX/GNU-style --flags.

Package acme provides an implementation of the Automatic Certificate Management Environment (ACME) spec.

Package autocert provides automatic access to certificates from Let's Encrypt and any other ACME-based CA.

Package argon2 implements the key derivation function Argon2.

Package bcrypt implements Provos and Mazières's bcrypt adaptive hashing algorithm.

Package blake2b implements the BLAKE2b hash algorithm defined by RFC 7693 and the extendable output function (XOF) BLAKE2Xb.

Package blake2s implements the BLAKE2s hash algorithm defined by RFC 7693 and the extendable output function (XOF) BLAKE2Xs.

Package blowfish implements Bruce Schneier's Blowfish encryption algorithm.

Package bn256 implements a particular bilinear group.

Package cast5 implements CAST5, as defined in RFC 2144.

Package chacha20poly1305 implements the ChaCha20-Poly1305 AEAD as specified in RFC 7539.

Package cryptobyte contains types that help with parsing and constructing length-prefixed, binary messages, including ASN.1 DER.

Package asn1 contains supporting types for parsing and building ASN.1 messages with the cryptobyte package.

Package curve25519 provides an implementation of scalar multiplication on the elliptic curve known as curve25519.

Package ed25519 implements the Ed25519 signature algorithm.

Package hkdf implements the HMAC-based Extract-and-Expand Key Derivation Function (HKDF) as defined in RFC 5869.

Package md4 implements the MD4 hash algorithm as defined in RFC 1320.

Package auth authenticates a message using a secret key.

Package box authenticates and encrypts small messages using public-key cryptography.

Package secretbox encrypts and authenticates small messages.

Package sign signs small messages using public-key cryptography.

Package ocsp parses OCSP responses as specified in RFC 2560.

Package openpgp implements high level operations on OpenPGP messages.

Package armor implements OpenPGP ASCII Armor, see RFC 4880.

Package clearsign generates and processes OpenPGP, clear-signed data.

Package elgamal implements ElGamal encryption, suitable for OpenPGP, as specified in "A Public-Key Cryptosystem and a Signature Scheme Based on Discrete Logarithms," IEEE Transactions on Information Theory, v.

Package errors contains common error types for the OpenPGP packages.

Package packet implements parsing and serialization of OpenPGP packets, as specified in RFC 4880.

Package s2k implements the various OpenPGP string-to-key transforms as specified in RFC 4800 section 3.7.1.

Package otr implements the Off The Record protocol as specified in http://www.cypherpunks.ca/otr/Protocol-v2-3.1.0.html

Package pbkdf2 implements the key derivation function PBKDF2 as defined in RFC 2898 / PKCS #5 v2.0.

Package pkcs12 implements some of PKCS#12.

Package poly1305 implements Poly1305 one-time message authentication code as specified in https://cr.yp.to/mac/poly1305-20050329.pdf.

Package ripemd160 implements the RIPEMD-160 hash algorithm.

Package salsa20 implements the Salsa20 stream cipher as specified in https://cr.yp.to/snuffle/spec.pdf.

Package salsa provides low-level access to functions in the Salsa family.

Package scrypt implements the scrypt key derivation function as defined in Colin Percival's paper "Stronger Key Derivation via Sequential Memory-Hard Functions" (https://www.tarsnap.com/scrypt/scrypt.pdf).

Package sha3 implements the SHA-3 fixed-output-length hash functions and the SHAKE variable-output-length hash functions defined by FIPS-202.

Package ssh implements an SSH client and server.

Package agent implements the ssh-agent protocol, and provides both a client and a server.

Package knownhosts implements a parser for the OpenSSH known_hosts host key database, and provides utility functions for writing OpenSSH compliant known_hosts files.

Package terminal provides support functions for dealing with terminals, as commonly found on UNIX systems.

Package test contains integration tests for the golang.org/x/crypto/ssh package.

Package tea implements the TEA algorithm, as defined in Needham and Wheeler's 1994 technical report, “TEA, a Tiny Encryption Algorithm”.

Package twofish implements Bruce Schneier's Twofish encryption algorithm.

Package xtea implements XTEA encryption, as defined in Needham and Wheeler's 1997 technical report, "Tea extensions."

Package xts implements the XTS cipher mode as specified in IEEE P1619/D16.

Package bpf implements marshaling and unmarshaling of programs for the Berkeley Packet Filter virtual machine, and provides a Go implementation of the virtual machine.

Package context defines the Context type, which carries deadlines, cancelation signals, and other request-scoped values across API boundaries and between processes.

Package ctxhttp provides helper functions for performing context-aware HTTP requests.

Package dict implements the Dictionary Server Protocol as defined in RFC 2229.

Package dnsmessage provides a mostly RFC 1035 compliant implementation of DNS message packing and unpacking.

Package html implements an HTML5-compliant tokenizer and parser.

Package atom provides integer codes (also known as atoms) for a fixed set of frequently occurring HTML strings: tag names and attribute keys such as "p" and "id".

Package charset provides common text encodings for HTML documents.

Package httpguts provides functions implementing various details of the HTTP specification.

Package httpproxy provides support for HTTP proxy determination based on environment variables, as provided by net/http's ProxyFromEnvironment function.

Package http2 implements the HTTP/2 protocol.

The h2i command is an interactive HTTP/2 console.

Package hpack implements HPACK, a compression format for efficiently representing HTTP header fields in the context of HTTP/2.

Package icmp provides basic functions for the manipulation of messages used in the Internet Control Message Protocols, ICMPv4 and ICMPv6.

Package idna implements IDNA2008 using the compatibility processing defined by UTS (Unicode Technical Standard) #46, which defines a standard to deal with the transition from IDNA2003.

Package ipv4 implements IP-level socket options for the Internet Protocol version 4.

Package ipv6 implements IP-level socket options for the Internet Protocol version 6.

Package nettest provides utilities for network testing.

Package netutil provides network utility functions, complementing the more common ones in the net package.

Package proxy provides support for a variety of protocols to proxy network data.

Package publicsuffix provides a public suffix list based on data from http://publicsuffix.org/.

Package route provides basic functions for the manipulation of packet routing facilities on BSD variants.

Package trace implements tracing of requests and long-lived objects.

Package webdav provides a WebDAV server implementation.

Package websocket implements a client and server for the WebSocket protocol as specified in RFC 6455.

Package xsrftoken provides methods for generating and validating secure XSRF tokens.

Package cpu implements processor feature detection for various CPU architectures.

Package unix contains an interface to the low-level operating system primitives.

Package svc provides everything required to build Windows service.

Package debug provides facilities to execute svc.Handler on console.

Package eventlog implements access to Windows event log.

Example service program that beeps.

Package mgr can be used to manage Windows service programs.

Package parse provides support for parsing benchmark results as generated by 'go test -bench'.

Package blog implements a web server for articles written in present format.

Package atom defines XML data structures for an Atom feed.

The benchcmp command displays performance changes between benchmarks.

Bundle creates a single-source-file version of a source package suitable for inclusion in a particular target package.

callgraph: a tool for reporting the call graph of a Go program.

Compilebench benchmarks the speed of the Go compiler.

Cover is a program for analyzing the coverage profiles generated by 'go test -coverprofile=cover.out'.

The digraph command performs queries over unlabelled directed graphs represented in text form.

The eg command performs example-based refactoring.

The fiximports command fixes import declarations to use the canonical import path for packages that have an "import comment" as defined by https://golang.org/s/go14customimport.

The getgo command installs Go to the user's system.

Command server serves get.golang.org, redirecting users to the appropriate getgo installer based on the request path.

The go-contrib-init command helps new Go contributors get their development environment set up for the Go contribution process.

The godex command prints (dumps) exported information of packages or selected package objects.

Godoc extracts and generates documentation for Go programs.

Command goimports updates your Go import lines, adding missing ones and removing unreferenced ones.

The gomvpkg command moves go packages, updating import declarations.

The gorename command performs precise type-safe renaming of identifiers in Go source code.

The gotype command, like the front-end of a Go compiler, parses and type-checks a single Go package.

Goyacc is a version of yacc for Go.

guru: a tool for answering questions about Go source code.

Package serial defines the guru's schema for -json output.

heapview is a tool for viewing Go heap dumps.

This program takes an HTML file and outputs a corresponding article file in present format.

Present displays slide presentations and articles.

ssadump: a tool for displaying and interpreting the SSA form of Go programs.

The stress utility is intended for catching sporadic failures.

Stringer is a tool to automate the creation of methods that satisfy the fmt.Stringer interface.

Command tip is the tip.golang.org server, serving the latest HEAD straight from the Git oven.

Toolstash provides a way to save, run, and restore a known good copy of the Go toolchain and to compare the object files generated by two toolchains.

Package intsets provides Sparse, a compact and fast representation for sparse sets of int values.

Package cover provides support for parsing coverage profiles generated by "go test -coverprofile=cover.out".

Package astutil contains common utilities for working with the Go AST.

Package buildutil provides utilities related to the go/build package in the standard library.

Package callgraph defines the call graph and various algorithms and utilities to operate on it.

Package cha computes the call graph of a Go program using the Class Hierarchy Analysis (CHA) algorithm.

This package provides Rapid Type Analysis (RTA) for Go, a fast algorithm for call graph construction and discovery of reachable code (and hence dead code) and runtime types.

Package static computes the call graph of a Go program containing only static call edges.

Package gccgoexportdata provides functions for reading export data files containing type information produced by the gccgo compiler.

Package gcexportdata provides functions for locating, reading, and writing export data files containing type information produced by the gc compiler.

Package loader loads a complete Go program from source code, parsing and type-checking the initial packages plus their transitive closure of dependencies.

Package packages provides information about Go packages, such as their path, source files, and imports.

The gopackages command is a diagnostic tool that demonstrates how to use golang.org/x/tools/go/packages to load, parse, type-check, and print one or more Go packages.

Package pointer implements Andersen's analysis, an inclusion-based pointer analysis algorithm first described in (Andersen, 1994).

Package ssa defines a representation of the elements of Go programs (packages, types, functions, variables and constants) using a static single-assignment (SSA) form intermediate representation (IR) for the bodies of functions.

Package ssa/interp defines an interpreter for the SSA representation of Go programs.

Package typeutil defines various utilities for types, such as Map, a mapping from types.Type to interface{} values.

Package vcs exposes functions for resolving import paths and using version control systems, which can be used to implement behavior similar to the standard "go get" command.

Package godoc is a work-in-progress (2013-07-17) package to begin splitting up the godoc binary into multiple pieces.

Package analysis performs type and pointer analysis and generates mark-up for the Go source view.

Package redirect provides hooks to register HTTP handlers that redirect old godoc paths to their new equivalents and assist in accessing the issue tracker, wiki, code review system, etc.

Package static exports a map of static file content that supports the godoc user interface.

Package util contains utility types and functions for godoc.

Package vfs defines types for abstract file system access and provides an implementation accessing the file system of the underlying OS.

Package gatefs provides an implementation of the FileSystem interface that wraps another FileSystem and limits its concurrency.

Package httpfs implements http.FileSystem using a godoc vfs.FileSystem.

Package mapfs file provides an implementation of the FileSystem interface based on the contents of a map[string]string.

Package zipfs file provides an implementation of the FileSystem interface based on the contents of a .zip file.

Package imports implements a Go pretty-printer (like package "go/format") that also adds or removes import statements as necessary.

Package playground registers HTTP handlers at "/compile" and "/share" that proxy requests to the golang.org playground service.

Package socket implements an WebSocket-based playground backend.

The present file format

Package eg implements the example-based refactoring tool whose command-line is defined in golang.org/x/tools/cmd/eg.

Package importgraph computes the forward and reverse import dependency graphs for all packages in a Go workspace.

Package rename contains the implementation of the 'gorename' command whose main function is in golang.org/x/tools/cmd/gorename.

Package satisfy inspects the type-checked ASTs of Go packages and reports the set of discovered type constraints of the form (lhs, rhs Type) where lhs is a non-trivial interface, rhs satisfies this interface, and this fact is necessary for the package to be well-typed.

Package check is a rich testing extension for Go's testing package.

Package fsnotify provides a platform-independent interface for file system notifications.

Package dom provides GopherJS bindings for the JavaScript DOM APIs.

Package util provides some helpers for working with GopherJS.

Package xhr provides GopherJS bindings for the XMLHttpRequest API.

Package fileutil contains code to work with shell files, also known as shell scripts.

Package interp implements an interpreter that executes shell programs.

Package shell contains high-level features that use the syntax and interp packages under the hood.

Package syntax implements parsing and formatting of shell programs.

concsh allows you to concurrently run commands from your shell.

The gotype command does syntactic and semantic analysis of Go files and packages like the front-end of a Go compiler.

gitgodoc allows you to view `godoc` documentation for different branches of a Git repository

gitlscurr is an extended version of git ls-files that aims to reflect the files currently on disk as opposed to the current index (deleted files are in the index but not on disk)

gjbt is a simple (temporary) wrapper for GopherJS to run tests in Chrome as opposed to NodeJS.

golistalldeps transitively lists all dependencies (package, test and xtest) of specified packages in a format identical to go list

mdreplace is a tool to help you keep your markdown README/documentation current.

modpub is a tool to help create a directory of vgo modules from a git respository.

pkgconcat is a simple tool that concatenates the contents of a package into a single file

watcher is a Linux-based directory watcher for triggering commands

Package srcimporter implements importing directly from source files rather than installed packages.

immutableGen is a go generate generator that creates immutable struct, map and slice type declarations from template type declarations.

Package ast defines the AST data structures used by gotoc.

Package gendesc generates descriptor protos from an AST.

Package parser parses proto files into gotoc's AST representation.

coreGen is a go generate generator that helps to automate writing the core of myitcv.io/react.

cssGen is a temporary code generator for the myitcv.io/react.CSS type

reactGen is a go generate generator that helps to automate the process of writing GopherJS React web applications.

reactVet is a vet program used to check the correctness of myitcv.io/react based packages.

stateGen is a go generate generator that helps to automate the process of creating state trees for use in GopherJS React web applications.

Package jsx allows you to render blocks of HTML as myitcv.io/react elements.