Library which that provides a TCP protocol abstraction for C++.

Collaborative editor that supports multiple documents in one session and a multi-user chat. Gobby allows multiple users to edit the same document together over the internet in real-time.

gomacro is an almost complete Go interpreter, implemented in pure Go. It offers both an interactive REPL and a scripting mode, and does not require a Go toolchain at runtime (except in one very specific case: import of a 3rd party package at runtime).

This package provides an implementation of the Jsonnet data templating language in Go. It is a feature-complete, production-ready implementation, compatible with the original Jsonnet C++implementation.

Gore is a Go REPL that offers line editing and auto-completion. Some of its features include:

• Line editing with history

• Multi-line input

• Package importing with completion

• Evaluates any expressions, statements and function declarations

• No ``evaluated but not used'' errors

• Code completion

• Showing documents

• Auto-importing (gore -autoimport)

Pronounced ``Go please'', this is the official Go language server developed by the Go team. It provides IDE features to any LSP-compatible editor.

Godoc extracts and generates documentation for Go programs. It looks at the packages it finds via $GOROOT and $GOPATH (if set). This behavior can be altered by providing an alternative $GOROOT with the -goroot flag.

This Package implements a Go analysis pass that verifies that an fxevent.Logger implementation handles all known fxevent types. As a special case for no-op or fake fxevent.Loggers, it ignores implementations that handle none of the event types.

mnc (my next cron) opens the user's crontab and echos the time when the next cronjob will be ran.

The godef command prints the source location of definitions in Go programs.

This package implements a syntax highlighter for a long list of programming languages. It takes source code and other structured text and converts it into syntax highlighted HTML, ANSI-coloured text, etc. Chroma is based heavily on Pygments, and includes translators for Pygments lexers and styles.

This package provides various Protocol Buffer extensions for the Go language, namely support for record length-delimited message streaming.

This package provides an in-memory B-Tree implementation for Go, useful as an ordered, mutable data structure.

term provides support functions for dealing with terminals, as commonly found on Unix systems.

This package provides the Go Telemetry server code and libraries, used for hosting telemetry.go.dev and instrumenting Go toolchain programs with opt-in telemetry.

Package expect provides support for interpreting structured comments in Go source code (including go.mod and go.work files) as test expectations.

This package implements logging analogous to C++ package glog INFO/ERROR/V setup. It provides functions that have a name matched by regex:.

This package provides Go support for the Protocol Buffers data serialization format.

This package provides most of the code for running a godoc server.

Juniper is a library of extensions to the Go standard library using generics, including containers, iterators, and streams.

• container/tree contains a Map and Set that keep elements in sorted order. They are implemented using a B-tree, which performs better than a binary search tree.

• container/deque contains a double-ended queue implemented with a ring buffer.

• container/xheap contains a min-heap similar to the standard library's container/heap but more ergonomic, along with a PriorityQueue that allows setting priorities by key.

• container/xlist contains a linked-list similar to the standard library's container/list, but type-safe.

• xslices contains some commonly-used slice operations, like Chunk, Reverse, Clear, and Join.

• iterator contains an iterator interface used by the containers, along with functions to manipulate them, like Map, While, and Reduce.

• stream contains a stream interface, which is an iterator that can fail. Useful for iterating over collections that require I/O. It has most of the same combinators as iterator, plus some extras like Pipe and Batch.

• parallel contains some shorthand for common uses of goroutines to process slices, iterators, and streams in parallel, like parallel.MapStream.

• xsort contains extensions to the standard library package sort. Notably, it also has the definition for xsort.Less, which is how custom orderings can be defined for sorting and also for ordered collections like from container/tree.

• You can probably guess what's in the packages xerrors, xmath, xmath/xrand, xsync, and xtime.

The avo package presents a familiar assembly-like interface that simplifies development without sacrificing performance.

This package provides Go concurrency primitives in addition to the ones provided by the language and sync and sync/atomic packages. The package provides several Golang submodules:

• errgroup - synchronization, error propagation, and Context cancellation for groups of goroutines working on subtasks of a common task

• semaphore - a weighted semaphore implementation

• singleflight - a duplicate function call suppression mechanism

• syncmap - a concurrent map implementation

The Common Expression Language (CEL) implements common semantics for expression evaluation, enabling different applications to more easily interoperate.

This package provides supplemental libraries offering Go support for low-level interaction with the operating system.