The OCI Image Format project creates and maintains the software shipping container image format spec (OCI Image Format).

This package implements a parser for uniform resource names (URN) as specified by IETF RFC 2141.

oras-go is a Go library for managing OCI artifacts, compliant with the OCI Image Format Specification and the OCI Distribution Specification. It provides unified APIs for pushing, pulling, and managing artifacts across OCI-compliant registries, local file systems, and in-memory stores.

Package kong aims to support arbitrarily complex command-line structures with as little developer effort as possible.

This package implements a fully persistent data structures - a data structure that always preserves the previous version of itself when it is modified. Such data structures are effectively immutable, as their operations do not update the structure in-place, but instead always yield a new structure. It's a stable fork of https://github.com/mndrix/ps.

run.Group is a universal mechanism to manage goroutine lifecycles, written to manage component lifecycles in func main for OK Log. It's useful in any circumstance where you need to orchestrate multiple goroutines as a unit whole.

Tengo is a small, dynamic, fast, secure script language for Go. Features:

• simple and highly readable syntax

• dynamic typing with type coercion

• higher-order functions and closures

• immutable values

• securely embeddable and extensible

• compiler/runtime written in native Go (no external deps or cgo)

• executable as a standalone language/REPL

• use cases: rules engine, state machine, data pipeline, transpiler

This package provides a file system abstraction for Go.

This package contains code that supplements the time package from the Go standard library.

In particular:

• a Clock interface, with a fake implementation that can be used in tests

• implementations of oglematchers.Matcher for time values

Package flags provides an extensive command line option parser. The flags package is similar in functionality to the go built-in flag package but provides more options and uses reflection to provide a convenient and succinct way of specifying command line options. It's an alternative fork of https://github.com/jessevdk/go-flags.

Package protect is a wrapper for OpenBSD's pledge and unveil system calls.

It allows one to safely call Unveil / Pledge on non-OpenBSD operating systems.

Quant provides an interface for image color quantizers.

This package provides a circular buffer object. The buffer can be written to infinitely, but has a fixed size, so only the last size bytes are ever retained.

winquit is a golang module that supports graceful shutdown of Windows applications through the sending and receiving of Windows quit events on Win32 message queues. This allows golang applications to implement behavior comparable to SIGTERM signal handling on UNIX derived systems. Additionally, it supports the graceful shutdown mechanism employed by Windows system tools, such as taskkill.exe.

This package provides jbenet's context extensions.

Diskv (disk-vee) is a simple, persistent key-value store written in the Go language. It starts with a simple API for storing arbitrary data on a filesystem by key, and builds several layers of performance-enhancing abstraction on top. The end result is a conceptually simple, but highly performant, disk-backed storage system.

ChunkReader is a io.Reader wrapper that minimizes IO reads and memory allocations. It allocates memory in chunks and will read as much as will fit in the current buffer in a single call regardless of how large a read is actually requested. The memory returned via Next is owned by the caller. This avoids the need for an additional copy. It extracted from original implementation in https://github.com/jackc/pgx.

Helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.

Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).

Package lxc provides Go Bindings for LXC (Linux Containers) C API.

Porter2 implements the english Porter2 stemmer. It is written completely using finite state machines to do suffix comparison, rather than the string-based or tree-based approaches.

Package silog provides a slog.Handler implementation that produces human-readable, logfmt-style output.

This package implements high-performance external sorting library for Go that enables sorting of arbitrarily large datasets that don't fit entirely in memory. The library operates on channels and uses temporary disk storage to handle datasets larger than available RAM.

It's an alternative fork of https://github.com/gdamore/tcell.

This package provides apparmor support for Go. AppArmor is a Linux kernel security module that allows the system administrator to restrict program's capabilities such as network access, raw socket access, and the permission to read, write, or execute files