Go

IPFS

IPFS (the InterPlanetary File System) is a new hypermedia distribution protocol, addressed by content and identities. IPFS enables the creation of completely distributed applications. It aims to make the web faster, safer, and more open.

IPFS is a distributed file system that seeks to connect all computing devices with the same system of files. In some ways, this is similar to the original aims of the Web, but IPFS is actually more similar to a single bittorrent swarm exchanging git objects. You can read more about its origins in the paper IPFS - Content Addressed, Versioned, P2P File System.

IPFS is becoming a new major subsystem of the internet. If built right, it could complement or replace HTTP. It could complement or replace even more. It sounds crazy. It is crazy.

Nanopack

Nanopack is a collection of libraries aimed at improving infrastructure development and management through a fundamentally different approach to building infrastructure components and services.

Libraries include:

• Yoke - Postgres high-availability cluster with auto-failover and automated cluster recovery.

• Redundis - Redis high-availability cluster using Sentinel to transparently proxy connections to the active primary member.

• Portal - An api-driven, in-kernel layer 2/3 load balancer.

• Logvac - Simple, lightweight, api-driven log aggregation service with realtime push capabilities and historical persistence.

• Hoarder - A simple, api-driven storage system for storing code builds and cached libraries for cloud-based deployment services.

• Shaman - Small, lightweight, api-driven dns server.

• Mist - A distributed, tag-based pub-sub service for modern web applications and container-driven cloud.

• more...

Snap

Snap — is an open telemetry framework designed to simplify the collection, processing and publishing of system data through a single API. The goals of this project are to:

• Empower systems to expose a consistent set of telemetry data

• Simplify telemetry ingestion across ubiquitous storage systems

• Allow flexible processing of telemetry data on agent (e.g. filtering and decoration)

• Provide powerful clustered control of telemetry workflows across small or large clusters

Gitql

Gitql — is a Git query language.

Cayley

Cayley — is an open-source graph inspired by the graph database behind Freebase and Google’s Knowledge Graph.

Its goal is to be a part of the developer’s toolbox where Linked Data and graph-shaped data (semantic webs, social networks, etc) in general are concerned.

Docker

Docker — is an open source project to pack, ship and run any application as a lightweight container.

Build Once. Ship Anywhere.

Kubernetes

Kubernetes — is an open source system for managing containerized applications across multiple hosts, providing basic mechanisms for deployment, maintenance, and scaling of applications. Kubernetes is hosted by the Cloud Native Computing Foundation.

Kubernetes builds upon a decade and a half of experience at Google running production workloads at scale using a system called Borg, combined with best-of-breed ideas and practices from the community.

Nanobox

Nanobox — is a cross-platform micro-PaaS (μPaaS) that allows developers to focus on application development, rather than the complexities of infrastructure configuration and management.

Nanobox creates isolated development environments (using Docker) which are staged locally, and deployed anywhere. This guarantees parity of application environments across entire teams throughout the development lifecycle (dev, staging, production, etc.).

cobra

cobra — a library for creating powerful modern CLI applications as well as a program to generate applications and command files.

Hyperd

Hyperd — is a hypervisor-agnostic technology that allows you to run Docker images on plain hypervisor.

Terraform

Terraform — is a tool for building, changing, and versioning infrastructure safely and efficiently. Terraform can manage existing and popular service providers as well as custom in-house solutions.

gago

gago — genetic algorithm toolkit written in Go. The following example attempts to minimize the Drop-Wave function.

Hugo

Hugo — a static HTML and CSS website generator written in Go. It is optimized for speed, easy use and configurability. Hugo takes a directory with content and templates and renders them into a full HTML website.

Gin

Gin — is a web framework written in Go. It features a martini-like API with much better performance, up to 40 times faster thanks to httprouter. If you need performance and good productivity, you will love Gin.

gobot

gobot — a framework using the Go programming language for robotics, physical computing, and the Internet of Things.

utron

utron — is a lightweight MVC framework in Go (Golang) for building fast, scalable and robust database-driven web applications.

Caddy

Caddy — a general-purpose web server for Windows, Mac, Linux, BSD, and Android. It is a capable but easier alternative to other popular web servers.

gitea

gitea — a community managed fork of Gogs, delivering a lightweight code hosting solution written in Go and published under the MIT license.

gogs

gogs — Gogs (Go Git Service) is a painless self-hosted Git service.

tile38

tile38 — an open source, in-memory geolocation data store, spatial index, and realtime geofence. It supports a variety of object types including lat/lon points, bounding boxes, XYZ tiles, Geohashes, and GeoJSON.

logrus

logrus — a structured logger for Golang, completely API compatible with the standard library logger.

traefik

traefik — a modern HTTP reverse proxy and load balancer made to deploy microservices with ease. It supports several backends (Docker, Swarm, Kubernetes, Marathon, Mesos, Consul, Etcd, Zookeeper, BoltDB, Eureka, Rest API, file…) to manage its configuration automatically and dynamically.

dry

dry — a terminal application to manage Docker containers and images. It aims to be an alternative to the official Docker CLI when it is needed to repeatedly execute commands on existing containers and images, and also as a tool to monitor Docker containers from a terminal.

pgweb

pgweb — Web-based PostgreSQL database browser written in Go.

rkt

rkt — (pronounced "rock-it") is a CLI for running app containers on Linux. rkt is designed to be secure, composable, and standards-based.

Some of rkt's key features and goals include:

• Security: rkt is developed with a principle of "secure-by-default", and includes a number of important security features like support for SELinux, TPM measurement, and running app containers in hardware-isolated VMs.

• Composability: rkt is designed for first-class integration with init systems (systemd, upstart) and cluster orchestration tools (fleet, Kubernetes, Nomad), and supports swappable execution engines.

• Open standards and compatibility: rkt implements the appc specification, supports the Container Networking Interface specification, can also run Docker images, and OCI images via docker2aci. Native OCI image support is in development.

Distribution

Distribution — The Docker toolset to pack, ship, store, and deliver content.

Flynn

Flynn — is an open source Platform as a Service. Flynn is designed to run anything that can run on Linux, not just stateless web apps. Flynn comes with highly available database appliances, including PostgreSQL, MySQL, and MongoDB.

Convox Rack

Convox Rack — is open source PaaS built on top of expert infrastructure automation and devops best practices.

Rack gives you a simple developer-focused API that lets you build, deploy, scale and manage apps on private infrastructure with ease.

GoReplay

GoReplay — is the simplest and safest way to test your app using real traffic before you put it into production.

As your application grows, the effort required to test it also grows exponentially. GoReplay offers you the simple idea of reusing your existing traffic for testing, which makes it incredibly powerful. Our state of art technique allows to analyze and record your application traffic without affecting it. This eliminates the risks that come with putting a third party component in the critical path.

Packer

Packer — is a tool for building identical machine images for multiple platforms from a single source configuration.

Packer is lightweight, runs on every major operating system, and is highly performant, creating machine images for multiple platforms in parallel. Packer comes out of the box with support for the following platforms:

• Amazon EC2 (AMI). Both EBS-backed and instance-store AMIs

• Azure

• DigitalOcean

• Docker

• Google Compute Engine

• OpenStack

• Parallels

• QEMU. Both KVM and Xen images.

• VirtualBox

• VMware

Support for other platforms can be added via plugins.

fzf

fzf — is a general-purpose command-line fuzzy finder.

InfluxDB

InfluxDB — is an open source time series database with no external dependencies. It's useful for recording metrics, events, and performing analytics.

Features

• Built-in HTTP API so you don't have to write any server side code to get up and running.

• Data can be tagged, allowing very flexible querying.

• SQL-like query language.

• Simple to install and manage, and fast to get data in and out.

• It aims to answer queries in real-time. That means every data point is

  indexed as it comes in and is immediately available in queries that

  should return in < 100ms.

Negroni. Idiomatic HTTP Middleware for Golang

Example:

package main

import (
  "fmt"
  "net/http"

  "github.com/urfave/negroni"
)

func main() {
  mux := http.NewServeMux()
  mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "Welcome to the home page!")
  })

  n := negroni.Classic() // Includes some default middlewares
  n.UseHandler(mux)

  http.ListenAndServe(":3000", n)
}

NSQ

NSQ — is a realtime distributed messaging platform designed to operate at scale, handling billions of messages per day.

It promotes distributed and decentralized topologies without single points of failure, enabling fault tolerance and high availability coupled with a reliable message delivery guarantee. See features & guarantees.

Operationally, NSQ is easy to configure and deploy (all parameters are specified on the command line and compiled binaries have no runtime dependencies). For maximum flexibility, it is agnostic to data format (messages can be JSON, MsgPack, Protocol Buffers, or anything else). Official Go and Python libraries are available out of the box (as well as many other client libraries) and, if you're interested in building your own, there's a protocol spec.

Blackfriday

Blackfriday — is a Markdown processor implemented in Go. It is paranoid about its input (so you can safely feed it user-supplied data), it is fast, it supports common extensions (tables, smart punctuation substitutions, etc.), and it is safe for all utf-8 (unicode) input.

HTML output is currently supported, along with Smartypants extensions. An experimental LaTeX output engine is also included.

IronFunctions

IronFunctions — is an open source serverless platform, or as we like to refer to it, Functions as a Service (FaaS) platform that you can run anywhere.

Gizmo. Microservice Toolkit This toolkit provides packages to put together server and pubsub daemons with the following features:

• standardized configuration and logging

• health check endpoints with configurable strategies

• configuration for managing pprof endpoints and log levels

• structured logging containing basic request information

• useful metrics for endpoints

• graceful shutdowns

• basic interfaces to define our expectations and vocabulary

testify

testify — a sacred extension to the standard go testing package.

Example:

package yours

import (
  "testing"
  "github.com/stretchr/testify/assert"
)

func TestSomething(t *testing.T) {

  // assert equality
  assert.Equal(t, 123, 123, "they should be equal")

  // assert inequality
  assert.NotEqual(t, 123, 456, "they should not be equal")

  // assert for nil (good for errors)
  assert.Nil(t, object)

  // assert for not nil (good when you expect something)
  if assert.NotNil(t, object) {

    // now we know that object isn't nil, we are safe to make
    // further assertions without causing any errors
    assert.Equal(t, "Something", object.Value)

  }

}

chi

chi — is a lightweight, idiomatic and composable router for building Go 1.7+ HTTP services. It's especially good at helping you write large REST API services that are kept maintainable as your project grows and changes. chi is built on the new context package introduced in Go 1.7 to handle signaling, cancelation and request-scoped values across a handler chain.

The focus of the project has been to seek out an elegant and comfortable design for writing REST API servers, written during the development of the Pressly API service that powers our public API service, which in turn powers all of our client-side applications.

The key considerations of chi's design are: project structure, maintainability, standard http handlers (stdlib-only), developer productivity, and deconstructing a large system into many small parts. The core router github.com/pressly/chi is quite small (less than 1000 LOC), but we've also included some useful/optional subpackages: middleware, render and docgen. We hope you enjoy it too!

go-callvis

go-callvis — a development tool to help visualize call graph of your Go program using Graphviz's dot format.

Purpose of this tool is to provide a visual overview of your program by using the data from call graph and its relations with packages and types. This is especially useful in larger projects where the complexity of the code rises or when you are just simply trying to understand code structure of somebody else.

fasthttp

fasthttp — is a fast HTTP implementation for Go.

Tyk

Tyk — is an open source, fast and scalable API management platform featuring an API gateway, API analytics, developer portal and API management dashboard.

frp

frp - A fast reverse proxy to help you expose a local server behind a NAT or firewall to the internet.

• Expose any http and https service behind a NAT or firewall to the internet by a server with public IP address(Name-based Virtual Host Support).

• Expose any tcp or udp service behind a NAT or firewall to the internet by a server with public IP address.

Gin

Gin is a web framework written in Go (Golang). It features a martini-like API with much better performance, up to 40 times faster thanks to httprouter. If you need performance and good productivity, you will love Gin.