The tview package implements rich widgets for terminal based user interfaces. The widgets provided with this package are useful for data exploration and data entry.

Goof (Go Object Finder) is a package that does the unthinkable to the binaryes: calling functions, fmt.Fprintf, and accessing reflect.Type from them.

This is a straight copy of the excellent Gomega library, stripped to the bare core to be free of third-party dependencies.

This package provides a pretty-printer for Go. The functions defined by pp follow an API similar to fmt and its configuration can be customized globally.

Rod is a high-level driver for Chrome DevTools Protocol. It's designed for web automation and scraping, providing a simple API to control Chrome or Chromium browsers programmatically.

Go-hdb is a native Go HANA database driver for Go's sql package. It implements the SAP HANA SQL command network protocol.

Chi is a lightweight, idiomatic and composable router for building Go HTTP services. It is based on the standard Go net/http package and supports middleware, routing groups, and URL parameters.

This package provides a parser for RDF files linearized using RDF/XML format. It is used to represent the RDF files in memory and write back in possibly different formats like JSON and XML.

cli is a simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.

Package ntp provides an implementation of a Simple NTP (SNTP) client capable of querying the current time from a remote NTP server as specified in RFC 5905.

sudo is a package to make reflect more powerful (and dangerous). It exports a single function, Sudo, which when passed a reflect.Value, will return a new reflect.Value with the read-only restrictions removed.

This package provides a minimal interface for structured logging in services. It may be wrapped to encode conventions, enforce type-safety, provide leveled logging, and so on. It can be used for both typical application log events, and log-structured data streams.

Dust is an Internet protocol designed to resist a number of attacks currently in active use to censor Internet communication. While adherence to the theoretical maxims of cryptographic security is observed where possible, the focus of Dust is on real solutions to real attacks.

Package cmd runs external commands with concurrent access to output and status. It wraps the Go standard library os/exec.Command to correctly handle reading output (STDOUT and STDERR) while a command is running and killing a command. All operations are safe to call from multiple goroutines.

This package provides ShāngMì 4 cipher suites implementation (GM SM2/3/4).

Main functions:

• SM2 national secret elliptic curve algorithm library

• SM3 national secret hash algorithm library

• SM4 national secret block cipher algorithm library

Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation.

Bine is a toolkit to assist in creating Tor clients and servers. Features:

• full support for the Tor controller API

• support for net.Conn and net.Listen style APIs

• supports statically compiled Tor to embed Tor into the binary

• supports v3 onion services

• support for embedded control socket in Tor >= 0.3.5

Smux (Simple MUltipleXing) is a multiplexing library for Golang. It relies on an underlying connection to provide reliability and ordering, such as TCP or KCP, and provides stream-oriented multiplexing. The original intention of this library is to power the connection management for kcp-go.

This package implements ULID as specified in https://github.com/ulid/spec.

Features of ULID:

• 128-bit compatibility with UUID

• 1.21e+24 unique ULIDs per millisecond

• lexicographically sortable

• canonically encoded as a 26 character string, as opposed to the 36 character UUID

• uses Crockford's base32 for better efficiency and readability (5 bits per character)

• case insensitive

• no special characters (URL safe)

• monotonic sort order (correctly detects and handles the same millisecond)

Versatile HTTP mocking made easy in Go that works with any net/http based stdlib implementation. Inspired by the Node nock library, it has features like:

• Simple and expressive API

• Semantic API DSL for declarative HTTP mock declarations

• Built-in helpers for easy JSON/XML mocking

• Supports persistent and volatile TTL-limited mocks

• Full regular expressions capable HTTP request mock matching

• Designed for both testing and runtime scenarios

• Match request by method, URL params, headers and bodies

• Extensible and pluggable HTTP matching rules

• Ability to switch between mock and real networking modes

• Ability to filter/map HTTP requests for accurate mock matching

• Supports map and filters to handle mocks easily

• Wide compatible HTTP interceptor using http.RoundTripper interface

• Works with any net/http compatible client, such as gentleman

• Network timeout/cancellation delay simulation

• Extensible and hackable API

Gcfg reads INI-style configuration files into Go structs.

Documentation at https://melpa.org/#/gitignore-templates