553 Resources
Golang implementation Libraries
A Golang blocking leaky-bucket rate limit implementation
Go rate limiter This package provides a Golang implementation of the leaky-bucket rate limit algorithm. This implementation refills the bucket based o
An efficient and feature complete Hystrix like Go implementation of the circuit breaker pattern.
Circuit Circuit is an efficient and feature complete Hystrix like Go implementation of the circuit breaker pattern. Learn more about the problems Hyst
A highly extensible Git implementation in pure Go.
go-git is a highly extensible git implementation library written in pure Go. It can be used to manipulate git repositories at low level (plumbing) or
An R-tree implementation for Go
rtree This package provides an in-memory R-Tree implementation for Go. It's designed for Tile38 and is optimized for fast rect inserts and replacement
Go implementation of SipHash-2-4, a fast short-input PRF created by Jean-Philippe Aumasson and Daniel J. Bernstein.
SipHash (Go) Go implementation of SipHash-2-4, a fast short-input PRF created by Jean-Philippe Aumasson and Daniel J. Bernstein (http://131002.net/sip
A Go implementation of the 64-bit xxHash algorithm (XXH64)
xxhash xxhash is a Go implementation of the 64-bit xxHash algorithm, XXH64. This is a high-quality hashing algorithm that is much faster than anything
A Blurhash implementation in pure Go (Decode/Encode)
go-blurhash go-blurhash is a pure Go implementation of the BlurHash algorithm, which is used by Mastodon an other Fediverse software to implement a sw
Data Structure Libraries and Algorithms implementation
Algorithms Data Structure Libraries and Algorithms implementation in C++ Disclaimer This repository is meant to be used as a reference to learn data s
:rowboat: Raft implementation in Go
🚣 Raft This is an instructional implementation of the Raft distributed consensus algorithm in Go. It's accompanied by a series of blog posts: Part 0:
Go (golang) implementation of http://www.hashids.org
go-hashids Go (golang) v1 implementation of http://www.hashids.org under MIT License (same as the original implementations) Original implementations b
The Go language implementation of gRPC. HTTP/2 based RPC
gRPC-Go The Go implementation of gRPC: A high performance, open source, general RPC framework that puts mobile and HTTP/2 first. For more information
Pure Go implementation of the WebRTC API
Pion WebRTC A pure Go implementation of the WebRTC API New Release Pion WebRTC v3.0.0 has been released! See the release notes to learn about new feat
An implementation of sed in Go. Just because!
Sed-Go An implementation of sed in Go. Just because! Status Command-Line processing: Done. It accepts '-e', '-f', '-n' and long versions of the same.
A reference implementation of blockchain in Go to demonstrate how blockchain works. For education purpose.
Mini-Blockchain Mini-Blockchain is a reference design for a blockchain system to demostate a full end2end flow in current blockchain technology. There
Go implementation of the traceroute tool
tracesite tracesite is a simple Go implementation of the traceroute tool Check out the blog post on explanation Install : Download binary from release
Rule engine implementation in Golang
"Gopher Holds The Rules" Grule-Rule-Engine import "github.com/hyperjumptech/grule-rule-engine" Rule Engine for Go Grule is a Rule Engine library for t
Dogecoin Rosetta API implementation
Dogecoin Rosetta API implementation ROSETTA-DOGECOIN IS UNDER INITIAL DEVELOPMENT AND IF IT IS NOT BROKEN, THIS IS ACCIDENTAL. DO NOT USE THIS SOFTWAR
Golang FrodoKEM implementation
FrodoKEM in Golang Golang implementation of FrodoKEM: a Practical quantum-secure key encapsulation from generic lattices (https://frodokem.org). This
WebAssembly for Proxies (Golang host implementation)
WebAssembly for Proxies (GoLang host implementation) The GoLang implementation for proxy-wasm, enabling developer to run proxy-wasm extensions in Go.
Fast RFC 5389 STUN implementation in go
STUN Package stun implements Session Traversal Utilities for NAT (STUN) [RFC5389] protocol and client with no external dependencies and zero allocatio
A typed implementation of the Go sync.Map using code generation
syncmap A typed implementation of the Go sync.Map using code generation. Install go get -u github.com/a8m/syncmap@master Examples: Using CLI $ syncma
Embedded, Fast and Persistent bigqueue implementation
bigqueue bigqueue provides embedded, fast and persistent queue written in pure Go using memory mapped (mmap) files. bigqueue is now thread safe as wel
benchmarks for implementation of servers which support 1 million connections
Benchmark for implementation of servers that support 1m connections inspired by handling 1M websockets connections in Go Servers 1_simple_tcp_server:
Fast implementation of base58 encoding on golang.
Fast Implementation of Base58 encoding Fast implementation of base58 encoding in Go. Base algorithm is adapted from https://github.com/trezor/trezor-c
A go implementation of Verkle trees
go-verkle A very experimental implementation of Verkle trees. When production-ready, the code is to be split between go-kzg and go-ethereum. Notes Nod
An open source re-implementation of Diablo 2
OpenDiablo2 Join us on Discord! Development Live stream Support us on Patreon We are also working on a toolset: https://github.com/OpenDiablo2/HellSpa
An implementation of the popular game Codenames created with Go and React.
OpenCodenames A real-time implementation of Codenames created with React/TypeScript and Golang. You can play the game here! Installation Stack: React
gokcp is go implementation based on KCP
gokcp gokcp是KCP (https://github.com/skywind3000/kcp) 的Go语言实现。 gokcp与KCP的不同点在于: 以位计算方式实现了ack list,好处是简化代码以及节约一个int32的大小。 实现另外一种RTO的计算方法,算法移植自Linux内核里面T
Implementation of the NELI leader election protocol for Go and Kafka
goNELI Implementation of the NELI leader election protocol for Go and Kafka. goNELI encapsulates the 'fast' variation of the protocol, running in excl
An early PostgreSQL implementation in Go
gosql An early PostgreSQL implementation in Go. Example $ git clone [email protected]:eatonphil/gosql $ cd gosql $ go run cmd/main.go Welcome to gosql. #
A Golang implementation of the Umee network, a decentralized universal capital facility in the Cosmos ecosystem.
Umee A Golang implementation of the Umee network, a decentralized universal capital facility in the Cosmos ecosystem. Umee is a Universal Capital Faci
Interblockchain communication protocol (IBC) implementation in Golang.
ibc-go Interblockchain communication protocol (IBC) implementation in Golang built as a SDK module. Components Core The core/ directory contains the S
Implementation of E(n)-Equivariant Graph Neural Networks, in Pytorch
EGNN - Pytorch Implementation of E(n)-Equivariant Graph Neural Networks, in Pytorch. May be eventually used for Alphafold2 replication.
Fast (linear time) implementation of the Gaussian Blur algorithm in Go.
Song2 Fast (linear time) implementation of the Gaussian Blur algorithm in Go.
`age-plugin-yubikey` implementation, encrypt things with a Yubikey/any PIV card
This is an age plugin for PIV cards/Yubikey. Your secret is kept safe on the tamperproof hardware, while letting you use the age command-line.
An example client implementation written in GO to access the CyberVox platform API
About This is an example client implementation written in GO to access the CyberVox platform API.
Go implementation of the Heaven's Gate technique
gopherheaven is a Go implementation of the classic Heaven's Gate technique originally published by roy g biv on VX Heaven in 2009. gopherheaven can be used as an evasion technique to directly call 64-bit code from a 32-bit process.
Tiny-HTTPS protocol implementation (experiment purpose.)
thttps Basic TLS implementation in Go, written as a learning project. Most components are forked from Go version 1.7 tiny-HTTPS is not suitable for re
Terraform provider implementation for interacting with the Tailscale API.
Terraform Provider Tailscale This repository contains a Terraform provider implementation for interacting with the Tailscale API.
Merchant API reference implementation
mAPI More details available in the BRFC Spec for Merchant API. The old golang (v1.1) implementation is no longer being maintained and has been moved t
A full node Bitcoin (BSV) implementation written in Go
bsvd bsvd is a full node Bitcoin (BSV) implementation written in Go (golang). This project is a port of the bchd codebase to Bitcoin (BSV). It provide
A simplified blockchain implementation in Golang
A simplified blockchain implementation in Golang
A Go implementation of fluent-ffmpeg
Go Fluent FFmpeg A Go version of node-fluent-ffmpeg. Installation go get -u github.com/modfy/fluent-ffmpeg Requirements You will need FFmpeg installed
A simple `fs.FS` implementation to be used inside tests.
testfs A simple fs.FS which is contained in a test (using testing.TB's TempDir()) and with a few helper methods. PS: This lib only works on Go 1.16+.
Implementation of io/fs.FS that appends SHA256 hashes to filenames to allow for aggressive HTTP caching.
hashfs Implementation of io/fs.FS that appends SHA256 hashes to filenames to allow for aggressive HTTP caching.
Fastest levenshtein implementation in Go.
fast-levenshtein 🚀 Fastest levenshtein implementation in Go. Measure the difference between two strings. note: this implementation is currently not t
A Go io/fs filesystem implementation for reading files in a Github gists.
GistFS GistFS is an io/fs implementation that enables to read files stored in a given Gist. Requirements This module depends on io/fs which is only av
An experimental GraphQL implementation with Go.
Description An experimental GraphQL implementation with Go. This repo focuses on improve GraphQL Parse and Resolve speed t
🚥 Yet another pinger: A high-performance ICMP ping implementation build on top of BPF technology.
yap Yet-Another-Pinger: A high-performance ICMP ping implementation build on top of BPF technology. yap uses the gopacket library to receive and handl
A diff3 text merge implementation in Go
Diff3 A diff3 text merge implementation in Go based on the awesome paper below. "A Formal Investigation of Diff3" by Sanjeev Khanna, Keshav Kunal, and
Implementation of do255e and do255s in Go
Go Implementation of do255e and do255s This is a plain Go implementation of do255e and do255s. It is considered secure; all relevant functions should
Simple Client Implementation of WebFinger
Go-Webfinger Go client for the Webfinger protocol Go-Webfinger is a Go client for the Webfinger protocol. *It is a work in progress, the API is not fr
go implementation of timsort
timsort timsort is a Go implementation of Tim Peters's mergesort sorting algorithm. For many input types it is 2-3 times faster than Go's built-in sor
Implementation of the FTPS protocol for Golang.
FTPS Implementation for Go Information This implementation does not implement the full FTP/FTPS specification. Only a small subset. I have not done a
A fast, well-tested and widely used WebSocket implementation for Go.
Gorilla WebSocket Gorilla WebSocket is a Go implementation of the WebSocket protocol. Documentation API Reference Chat example Command example Client
A golang implementation of Norvig's segmenter
A Go language implementation of the Norvig segmenter, given in this pdf. Licensed WTFPL; please use this code in any way you would like. func MakeWord
Templating system for HTML and other text documents - go implementation
FAQ What is Kasia.go? Kasia.go is a Go implementation of the Kasia templating system. Kasia is primarily designed for HTML, but you can use it for any
Go implementation of the bspatch algorithm
binarydist Package binarydist implements binary diff and patch as described on http://www.daemonology.net/bsdiff/. It reads and writes files compatibl
Go implementation of the XDG Base Directory Specification and XDG user directories
xdg Provides an implementation of the XDG Base Directory Specification. The specification defines a set of standard paths for storing application file
Functional programming library for Go including a lazy list implementation and some of the most usual functions.
functional A functional programming library including a lazy list implementation and some of the most usual functions. import FP "github.com/tcard/fun
Package git provides an incomplete pure Go implementation of Git core methods.
git Package git provides an incomplete pure Go implementation of Git core methods. Example Code: store := git.TempStore() defer os.RemoveAll(string(st
easyssh-proxy provides a simple implementation of some SSH protocol features in Go
easyssh-proxy easyssh-proxy provides a simple implementation of some SSH protocol features in Go. Feature This project is forked from easyssh but add
Go implementation of the Rust `dbg` macro
godbg 🐛 godbg is an implementation of the Rust2018 builtin debugging macro dbg. The purpose of this package is to provide a better and more effective
Swagger 2.0 implementation for go
Swagger 2.0 This package contains a golang implementation of Swagger 2.0 (aka OpenAPI 2.0): it knows how to serialize and deserialize swagger specific
RFC 4566 SDP implementation in go
SDP Package sdp implements SDP: Session Description Protocol [RFC4566]. Complies to gortc principles as core package. Examples See examples folder. Al
An implementation of failpoints for Golang.
failpoint An implementation of failpoints for Golang. Fail points are used to add code points where errors may be injected in a user controlled fashio
Go implementation for Soy templates (Google Closure templates)
soy Go implementation for Soy templates aka Google Closure Templates. See godoc for more details and usage examples. This project requires Go 1.12 or
Templating system for HTML and other text documents - go implementation
FAQ What is Kasia.go? Kasia.go is a Go implementation of the Kasia templating system. Kasia is primarily designed for HTML, but you can use it for any
Pure Go implementation of the NaCL set of API's
go-nacl This is a pure Go implementation of the API's available in NaCL: https://nacl.cr.yp.to. Compared with the implementation in golang.org/x/crypt
A probably paranoid Golang utility library for securely hashing and encrypting passwords based on the Dropbox method. This implementation uses Blake2b, Scrypt and XSalsa20-Poly1305 (via NaCl SecretBox) to create secure password hashes that are also encrypted using a master passphrase.
goSecretBoxPassword This is a Golang library for securing passwords it is based on the Dropbox method for password storage. The both passphrases are f
:wink: :cyclone: :strawberry: TextRank implementation in Golang with extendable features (summarization, phrase extraction) and multithreading (goroutine) support (Go 1.8, 1.9, 1.10)
TextRank on Go This source code is an implementation of textrank algorithm, under MIT licence. The minimum requred Go version is 1.8. MOTIVATION If th
Weighted PageRank implementation in Go
pagerank Weighted PageRank implementation in Go Usage package main import ( "fmt" "github.com/alixaxel/pagerank" ) func main() { graph := pagera
GO Implementation of Entropy Measures
goent - GO Implementation of Entropy Measures Measures for discrete state spaces Averaged measures Entropy Shannon Maximum Likelihood with Bias Correc
An implementation of GraphQL for Go / Golang
graphql An implementation of GraphQL in Go. Follows the official reference implementation graphql-js. Supports: queries, mutations & subscriptions. Do
Golang implementation of the Paice/Husk Stemming Algorithm
##Golang Implementation of the Paice/Husk stemming algorithm This project was created for the QUT course INB344. Details on the algorithm can be found
Server-sent live updates: protocol and reference implementation
Protocol and Reference Implementation Mercure is a protocol allowing to push data updates to web browsers and other HTTP clients in a convenient, fast
mangos is a pure Golang implementation of nanomsg's "Scalablilty Protocols"
mangos Mangos™ is an implementation in pure Go of the SP (“Scalability Protocols”) messaging system. These are colloquially known as a “nanomsg”. ❗ Th
Package notify provides an implementation of the Gnome DBus Notifications Specification.
go-notify Package notify provides an implementation of the Gnome DBus Notifications Specification. Examples Display a simple notification. ntf := noti
The implementation of the pattern observer
Event This is package implements pattern-observer Fast example import ( "github.com/agoalofalife/event" ) func main() { // create struct e := even
🔊Minimalist message bus implementation for internal communication
🔊 Bus Bus is a minimalist event/message bus implementation for internal communication. It is heavily inspired from my event_bus package for Elixir la
This is a go implementation of Segmented Sieve and non Segmented sieve to produce prime numbers concurrently.
Prime This is a Go library to produce prime numbers using all available cpu cores. Installation $ go get github.com/kavehmz/prime Usage package main
Go implementation of BLAS (Basic Linear Algebra Subprograms)
Go implementation of BLAS (Basic Linear Algebra Subprograms) Any function is implemented in generic Go and if it is justified, it is optimized for AMD
Golang implementation of the Paice/Husk Stemming Algorithm
##Golang Implementation of the Paice/Husk stemming algorithm This project was created for the QUT course INB344. Details on the algorithm can be found
An implementation of Neural Turing Machines
Neural Turing Machines Package ntm implements the Neural Turing Machine architecture as described in A.Graves, G. Wayne, and I. Danihelka. arXiv prepr
A native Go clean room implementation of the Porter Stemming algorithm.
Go Porter Stemmer A native Go clean room implementation of the Porter Stemming Algorithm. This algorithm is of interest to people doing Machine Learni
k-modes and k-prototypes clustering algorithms implementation in Go
go-cluster GO implementation of clustering algorithms: k-modes and k-prototypes. K-modes algorithm is very similar to well-known clustering algorithm
Go implementation of the Snowball stemmers
Snowball A Go (golang) implementation of the Snowball stemmer for natural language processing. Status Latest release v0.7.0 (2020-11-30) Latest build
A Statsd implementation written in GO lang
statsgod Statsgod is a metric aggregation service inspired by the statsd project. Written in Golang, it increases performance and can be deployed with
graylog-golang is a full implementation for sending messages in GELF (Graylog Extended Log Format) from Go (Golang) to Graylog
graylog-golang is a full implementation for sending messages in GELF (Graylog Extended Log Format) from Go (Golang) to Graylog
Go implementation of systemd Journal's native API for logging
journald Package journald offers Go implementation of systemd Journal's native API for logging. Key features are: based on a connection-less socket wo
An Etsy StatsD (https://github.com/etsy/statsd) implementation in Go
STATSD-GO Port of Etsy's statsd, written in Go. This was forked from https://github.com/amir/gographite to provide Ganglia submission support. USAGE U
A Windows named pipe implementation written in pure Go.
npipe Package npipe provides a pure Go wrapper around Windows named pipes. Windows named pipe documentation: http://msdn.microsoft.com/en-us/library/w
A Socket.IO backend implementation written in Go
go-socket.io The socketio package is a simple abstraction layer for different web browser- supported transport mechanisms. It is fully compatible with
A LWM2M Client and Server implementation (For Go/Golang)
Betwixt - A LWM2M Client and Server in Go Betwixt is a Lightweight M2M implementation written in Go OMA Lightweight M2M is a protocol from the Open Mo
Pure Go implementation of the WebRTC API
Pion WebRTC A pure Go implementation of the WebRTC API New Release Pion WebRTC v3.0.0 has been released! See the release notes to learn about new feat
Fast RFC 5389 STUN implementation in go
STUN Package stun implements Session Traversal Utilities for NAT (STUN) [RFC5389] protocol and client with no external dependencies and zero allocatio
A QUIC implementation in pure go
A QUIC implementation in pure Go quic-go is an implementation of the QUIC protocol in Go. It implements the IETF QUIC draft-29 and draft-32. Version c
A go implementation of the STUN client (RFC 3489 and RFC 5389)
go-stun go-stun is a STUN (RFC 3489, 5389) client implementation in golang (a.k.a. UDP hole punching). RFC 3489: STUN - Simple Traversal of User Datag
Golax, a go implementation for the Lax framework.
Golax is the official go implementation for the Lax framework. About Lax Getting started Routing example Performance How interceptor works Handling pa