Future articles and content will be updated to the Github project, welcome to follow.

Directories (using Ctrl+F)

introductory

A novice

  • 50 Common Mistakes made by New Golang Developers

The data type

  • You don’t even know the difference between a nil slice and an empty slice? The BAT interviewer will have to send you home to wait for the announcement.

  • Golang: Does memory copy happen when a string is converted into a byte array?

  • Golang Interview question: Flip the string containing Chinese characters, numbers, and English letters

  • Golang: Is it necessarily more expensive to copy a large slice than a small one?

  • What happens if map is not initialized

  • Map does not initialize length and initialization length difference

  • How big is the map? What if it is large

  • Is the map iterator secure? Can I delete and iterate at the same time?

  • You can’t change a string. Can you change an array? How

  • How do I tell if an array is sorted

  • How does a regular map solve coroutine security without locking

  • Difference between Array and Slice

  • Golang: What happens to json package variables without tags?

  • What are zero slices, empty slices, nil slices

  • Slice Deep copy and shallow copy

  • When does the map trigger capacity expansion? What condition does the map trigger capacity expansion?

  • What is the MAP capacity expansion policy

  • Custom type slice to byte slice and byte slice back to automatically slice by type

  • What’s the difference between make and new

  • What are the meanings of the parameters for slice, map, and Chanel

  • How is thread-safe map implemented

Process control

  • Is yesterday’s colleague from the append element in the for loop still around today?

  • Golang interviewer: What happens if the channel is already closed for select? What if there’s only one case?

The advanced

Package management

  • Just learn go Mod!

To optimize the

  • Golang interview question: How to avoid memory escape?

  • Golang interview question: What about memory escape?

  • Shame on everyone. After three years of golang, I still can’t get this memory leak question right

  • Memory fragmentation problem

  • Chan related goroutine leak issue

  • String related goroutine leak problem

  • You are bound to encounter suspected memory leaks caused by memory reclamation strategies

  • Sync. Pool application scenario

  • Go1.13 sync.Pool Compare the optimization points of go1.12

Concurrent programming

  • Golang Interview question: What would it be like to read and write the chan that has been turned off? Why is that?

  • Golang interview question: What about reading and writing uninitialized Chan? Why is that?

  • Advantages, disadvantages and usage scenarios of sync.map

  • Optimization points for sync.map

package

  • Commonly used official package instructions
  • Description of common third-party packages
  • Common framework
  • Complete list of standard libraries
  • Excellent third party library

    • Audio and Music

    • Data structures: Common data structures and algorithms in Go

    • Distributed Systems: Common data structures and algorithms in Go

    • E-mail: Libraries and tools that enable E-mail creation and delivery

    • Embedded scripting languages: Embed other languages in go code

    • Error handling

    • Libraries that handle files and file systems

    • Finance: Accounting and finance packages

    • Game development: Game development library

    • Geolocation: A library of geolocation information and tools

    • Compiler specific: Go to another language

    • Goroutines: Tools for managing and using Goroutines

    • Graphical interfaces: Libraries for building GUI applications

    • Image: Library for processing images

    • Iot: Iot device programming library

    • JSON format: A library for processing JSON

    • Machine learning: Common machine learning libraries

    • Microsoft Office

    • Natural language processing

    • Network: A library that works with each layer of the network

    • Video: Library for processing video

Advanced features

  • Golang: What’s the difference between uintptr and unsafe.Pointer?

  • Golang interview question: How do reflect get field tag? Why can’t json packages export tags for private variables?

  • Coroutines and threads

  • What is the recycling process like?

  • What are write barriers and hybrid write barriers, and how are they implemented?

  • Writer = (*myWriter)(nil).

  • GMP model

  • How is it scheduled between coroutines

  • What about the STW of GC

  • Using golang feature, design a SERVER with QPS of 500

  • Why does GC slow things down

  • What is the difference between opening multiple threads and opening multiple coroutines

  • Interface {} can be compared

  • A case where memory alignment must be done manually

  • Go stack expansion and stack shrinkage, continuous stack disadvantages

  • How does Golang optimize code

  • Golang Hidden Skill: How do I access private members

Troubleshoot problems

  • trace
  • pprof

The source code to read

  • sync.map
  • net/http
  • mutex
  • channel
  • context
  • Select implementation principle
  • The startup process behind the main function
  • Memory management
  • GC garbage collection
  • timer

assembly

  • Introduction to assembly
  • Recommended books
  • Video tutorial

Practical tools

  • Mysql > golang struct

  • Turn json golang struct

  • Turn toml golang struct

  • Yaml turn golang struct

other

Common official bag

  • FMT – Implements formatted input/output operations, of which fmt.printf () and fmt.println () are the most frequently used functions by developers.

  • IO – Implements a number of non-platform-specific IO related interfaces and implementations, such as providing encapsulation of system-specific IO functionality in the OS. We often use this package when we do streaming reads and writes, such as reading and writing files.

  • Bufio – It provides caching capabilities on top of IO. With caching in place, Bufio can easily provide operations like ReadLine.

  • Strconv – Provides the ability to interconvert strings to primitive data types.

  • OS – This package provides non-platform specific access to operating system functions. The interface is unix-style. The functions provided include file operation, process management, signals and user accounts.

  • Sync – This provides basic synchronization primitives. The locking mechanism provided in Sync is used when multiple Goroutines access a shared resource.

  • Flag – provides rule definition of command line arguments and parsing of incoming arguments. Most command-line programs need this package.

  • Encoding /json – JSON is widely used for communication in network programs. This package provides basic support for JSON, such as serializing from an object to a JSON string or deserializing from a JSON string to a concrete object.

  • HTTP – With HTTP packages, you can implement a crawler or a Web server with just a few lines of code, which is unimaginable in traditional languages.

Common third-party packages

  • Database operations – github.com/jinzhu/gorm github.com/go-xorm/xor…

  • Search es – github.com/olivere/ela…

  • Rocketmq operation – github.com/apache/rock…

  • Rabbitmq operation – github.com/streadway/a…

  • Redis operation – github.com/go-redis/re…

  • Etcd operation – github.com/coreos/etcd…

  • Kafka – github.com/Shopify/sar… Github.com/bsm/sarama-…

  • Excel operations – github.com/360EntSecGr…

  • PPT operation – golang.org/x/tools/cmd…

  • Go-svg operation – github.com/ajstarks/sv…

  • Go Bloom filter implementation – github.com/AndreasBrie…

  • Json related – github.com/bitly/go-si…

  • LRU Cache implementation – github.com/bluele/gcac… Github.com/hashicorp/g…

  • Go runtime function replacement – github.com/bouk/monkey…

  • Toml – github.com/toml-lang/t… Github.com/naoina/toml…

  • Yaml – github.com/go-yaml/yam…

  • 9 – github.com/spf13/viper…

  • Go Key/Value storage – github.com/etcd-io/bbo…

  • Ringbuffer Based lockless Golang workpool – github.com/Dai0522/wor…

  • Lightweight coroutine pool – github.com/ivpusic/grp…

  • Print detailed data structures for GO – github.com/davecgh/go-…

  • Ringbuffer based queue implementation – github.com/eapache/que…

  • Pinyin – github.com/go-ego/gpy…

  • Participle – github.com/go-ego/gse…

  • Search – github.com/go-ego/riot…

  • Windows COM – github.com/go-ego/ceda…

  • The session – github.com/gorilla/ses…

  • Routing – github.com/gorilla/mux…

  • Websocket – github.com/gorilla/web…

  • The Action handler – github.com/gorilla/han…

  • CSRF – github.com/gorilla/csr…

  • The context – github.com/gorilla/con…

  • Filter HTML tags – github.com/grokify/htm…

  • Configurable HTML tag filtering – github.com/microcosm-c…

  • Obtain location information by IP – github.com/ipipdotnet/…

  • HTML to markdown – github.com/jaytaylor/h…

  • Goroutine local storage – github.com/jtolds/gls…

  • Color output – github.com/mgutz/ansi

  • Form printing – github.com/olekukonko/…

  • Reflect’s more efficient reflection API – github.com/modern-go/r…

  • MSGFMT (formatting string, replacing % with variable name) – github.com/modern-go/m…

  • Cancelable Goroutine – github.com/modern-go/c…

  • Deep copy – github.com/mohae/deepc…

  • Secure type conversion package – github.com/spf13/cast

  • Extract links from text – github.com/mvdan/xurls

  • String formatting (hump conversion) – godoc.org/github.com/…

  • Text diff implementation – github.com/pmezard/go-…

  • Uuid related – github.com/satori/go.u… github.com/snluu/uuid

  • Remove BOM – github.com/ssor/bom from UTF encoding

  • Image zoom – github.com/nfnt/resize

  • Generate mock Server – github.com/otokaze/moc…

  • Go Performance Reported to Influxdb – github.com/rcrowley/go…

  • Go ZooKeeper client – github.com/samuel/go-z…

  • Go thrift – github.com/samuel/go-t…

  • MQTT client – github.com/shirou/mqtt…

  • Hbase – github.com/tsuna/gohba…

  • Go Performance Reported to Influxdb – github.com/rcrowley/go…

  • Go Performance reported to Prometheus – github.com/deathowl/go…

  • Ps utils – github.com/shirou/gops…

  • Decimals – github.com/shopspring/…

  • Structured Log Processing (JSON) – github.com/sirupsen/lo…

  • Command-line framework CLI – github.com/urfave/cli

  • Command line framework cobra-github.com/spf13/cobra

Will the project

  • Gin – github.com/olivere/ela… – Lightweight Web framework on which many companies have made magic changes

  • Beego – github.com/beego/beego – Also a Web framework, more versatile

  • Kratos – github.com/go-kratos/k… – Bilibili open source micro-service framework, B station produced must belong to the fine – product

  • TiDB – github.com/pingcap/tid… – A database you’ll want to choose after you’ve seen mysql performance bottlenecks

Other excellent open source tools category

Audio and Music

  • EasyMIDI – EasyMIDI is a simple and reliable library for handling standard Midi files (SMF).

  • Flac – Native Go FLAC encoder/decoder that supports FLAC streams.

  • Gaad – Native Go AAC bitstream parser.

  • Go-sox – For the LIBSOX binding of GO.

  • Go_mediainfo – The libMediainfo binding for go.

  • Gosamplerate – The libsamplerate binding for GO.

  • Id3v2 – Fast, stable ID3 parsing and authoring library for Go.

  • Malgo – Mini audio library.

  • Minimp3 – Lightweight MP3 decoder library.

  • Mix – Go to local audio mixer based on sequence for music applications.

  • Mp3 – Native Go MP3 decoder.

  • The music theory model in music-theory-Go.

  • Oto – A low-level library for playing sound on multiple platforms.

  • PortAudio – Used to bind the PortAudio audio I/O library.

  • Portmidi – Binds portMIDI.

  • Taglib – Binds to taglib.

  • Vorbis – “native” Go Vorbis decoder (uses CGO, but has no dependencies).

  • Detection-go package, capable of generating waveform images from an audio stream.

The data structure

  • Algorithms – Algorithms and data structures. Research on CLRS.

  • Binpacker – Binary packer and unpacker helps users build custom binary streams.

  • Bit – Golang Settings data structure with additional bit rotation capabilities.

  • Bitset – a Go package that implements the bitset.

  • Bloom – The Bloom filter implemented in Go.

  • Bloom – Golang Bloom filter implementation.

  • Boomfilters – Probabilistic data structures for processing continuous unbounded streams.

  • Concurrent-writer – Replaces bufio.Writer directly with high concurrency.

  • Conjungo – a small, powerful and flexible merge library.

  • Count-min-log – Performs a count-min-log sketch: Performs an approximate count using an approximate counter (similar to a count-min sketch, but using less memory).

  • The Crunch-go package implements buffers for easy processing of various data types.

  • Cuckoofilter – Cuckoo filter: a good alternative to the counting Bloom filter implemented in Go.

  • Deque – Highly optimized two-ended queue.

  • Deque – Fast ring buffer double-endian queue (double-endian queue).

  • Dict-go’s Python-like dictionary (dict).

  • Encoding-go integer compression library.

  • The GO implementation of Go-adaptive radix tree.

  • Go -datastructures – collection of useful, high-performance, and thread-safe datastructures.

  • Go implementation of go-EF-Elias-Fano code.

  • Go-geoindex – Geographic index in memory.

  • Go-mcache – Fast memory key: value store/cache library. Pointer cache.

  • Go-rquad – A regional quadtree with efficient point location and neighbor discovery.

  • Gocache – Complete Go cache library with multiple stores (memory, memcache, Redis, etc.), linkable, loadable, metric cache, etc.

  • Goconcurrentqueue – Concurrent FIFO queues.

  • Gods – Data structures. Containers, collections, lists, stacks, maps, BidiMaps, trees, Hashsets, etc.

  • Gofal-go’s decimal API.

  • Golang-set-go’s thread-safety and non-thread-safety high performance set.

  • Goset-go useful Set Set implementation.

  • Skip list implementation in Goskiplist-go.

  • Gota-go data box, sequence and data collation method implementation.

  • The hide-id type is marshalled into and out of hashes to prevent ids from being sent to clients.

  • The Hilbert-go package is used to map values between space-filling curves such as Hilbert and Peano curves.

  • Hyperloglog – Hyperloglog implementation, with sparse, LogLog-Beta bias correction and TailCut space reduction features.

  • Iter – C ++ STL iterator and algorithm implementation.

  • Levenshtein – Levenshtein distance and similarity metrics, with customizable editing fees and Winkler like bonuses for common prefixes.

  • Levenshtein – An implementation of calculating Levenshtein distance in Go.

  • Mafsa – Ma-FSA implementation with minimum perfect hashes.

  • The realization of Merkletree – Merkle tree can verify the content of data structure effectively and safely.

  • MSPM – Multi-string pattern matching algorithm for information retrieval.

  • Null – can be idled to type and can be marshalled/unmarshalled to/from JSON.

  • Parsefields – a tool for parsing JSON-like logs to collect unique fields and events.

  • Pipeline – Implementation of pipelines with fan in and fan out.

  • Ptrie – An implementation of the prefix tree.

  • Remember -go – Generic interface for caching slow database queries (supported by Redis, memcached, ristretto, or memory).

  • Ring-go implements a high-performance, thread-safe Bloom filter.

  • Roaring – A package that implements compressed bit set.

  • Set – Simple data structure implementation of go Settings using LinkedHashMap.

  • Skiplist – Very fast Go Skiplist implementation.

  • Skiplist implementation in skiplist-go.

  • Timedmap – map with expired key/value pairs.

  • Treap – Persistent quicksort map using tree heaps.

  • Trie implementation in Trie-Go.

  • Ttlcache – LRU string interface {} mapping in memory, which contains the expiry time of golang.

  • Typ – Empty types, safe primitive conversions and fetching values from complex structures.

  • Willf/Bloom-Go packages implement bloom filters.

Distributed system

  • Celeriac – library for adding support in Go to interact with and monitor Celery workers, tasks and events.
  • Consistent – a consistent hash with limited load
  • DHT – BitTorrent Kademlia DHT implementation.
  • Digota-grpc e-commerce micro service.
  • Dot – Distributed synchronization using operation transformation/OT.
  • Doublejump – Improved Google jump consistency hash.
  • Dragonboat-go is a fully featured high performance multi-set Raft library.
  • Drmaa – Job submission library for cluster schedulers based on drMAA standards.
  • Dynamolock – Distributed locking implemented by DynamoDB.
  • Dynatomic – Uses DynamoDB as a library for atomic counters.
  • Emitters IO – High performance, distributed, secure and low latency publish-subscribe platform built using MQTT, Websockets, and Love.
  • Flowgraph – Flow-based programming package.
  • Gleam – Fast and scalable distributed map/Reduce system with pure Go and Luajit, with the high performance of Luajit combined with the high concurrency of Go, run alone or distributed.
  • Glow – Easy to use scalable distributed big data processing, map-reduce, DAG execution, all in pure Go.
  • Go-health-health – Library used to enable asynchronous dependency health checking in the service.
  • Go-jump-port for Google’s “jump” consistency hash function.
  • Go-kit – A microservice toolkit that supports service discovery, load balancing, pluggable transport, request tracing, and more
  • Go-sundheit – Build a library to support defining asynchronous service health checks for Golang services.
  • Gorpc – Simple, fast and extensible RPC library for high loads.
  • GRPC – GO – GRPC go language implementation. RPC based on HTTP / 2.
  • Hprose – A very new RPC library that now supports over 25 languages.
  • Jsonrpc – The JSONRPC package helps implement JSON-RPC 2.0.
  • Jsonrpc-json-rpc 2.0 HTTP client implementation.
  • KrakenD – Ultra-high performance API gateway framework with middleware.
  • Liftbridge-nats lightweight, fault-tolerant message flow.
  • Micro – Pluggable microService toolkit and distributed system platform.
  • NATS – Lightweight high-performance messaging system for microservices, IoT and cloud native systems.
  • Outboxer – Outboxer is a Go library that implements the library pattern.
  • Pglock – PostgreSQL distributed locking implementation.
  • Raft – Golang implementation of HashiCorp’s RAFT Consensus protocol.
  • Raft-go implements raft consistency protocol by CoreOS.
  • Rain-bittorrent client and library.
  • Redis-lock – A simplified distributed locking implementation using Redis.
  • Resgate – A real-time API gateway for building REST, real-time, and RPC apis where all clients can seamlessly synchronize.
  • Extensible, fault-tolerant application layer sharding for Ringpop-Go-Go applications.
  • RPCX – Distributed pluggable RPC service framework, such as Alibaba Dubbo.
  • Sleuth – A library (ZeroMQ) for unsolicited P2P automatic discovery and RPC between HTTP services.
  • Tendermint – High performance middleware for converting a state machine written in any programming language into a Byzantine fault tolerant copy state machine using tendermint Consensus and blockchain protocol.
  • Torrent – BitTorrent client software package.

E-mail

  • Chasquid – SMTP server written in Go.
  • Douceur – CSS is lined for your HTML email.
  • Email – a powerful and flexible email library for Go.
  • Go-dkim-dkim library for signing and verifying E-mail.
  • Go-imap – An IMAP library for both clients and servers.
  • Go-message – A flow library of Internet message formats and mail messages.
  • Go-premailer-inline style for HTML messages in GO.
  • Go-simple-mail – very simple package for sending email using SMTP to stay active and two timeouts: Connect and send.
  • Hectane – Lightweight SMTP client providing HTTP API.
  • Herm-golang software package that generates clean, responsive HTML email.
  • Mailchain – Sends encrypted email to a blockchain address written in Go.
  • Mailgun-go-go library, used to send mail using the Mailgun API.
  • MailHog – Email and SMTP testing via Web and API interfaces.
  • SendGrid – The Go library of SendGrid for sending email.
  • SMTP – Indicates the protocol state machine of the SMTP server.

Embedded scripting language

  • Anko – scriptable interpreter written in the Go language.

  • Binder – Go to the Lua binding library based on Gopher – Lua.

  • Cel-go – Fast, portable, non-Turing complete expression evaluation with progressive input capabilities.

  • Expr – An engine that can evaluate expressions.

  • Gentee – Embeddable scripting language.

  • Simple LISP in GISP-Go.

  • Go-duktape – Go duktape JavaScript engine binding.

  • Go-lua – Lua 5.2 VM ports to pure Go.

  • PHP binding for go-php-go.

  • Go-python – Naive GO binding with CPython C-API.

  • Golua-lua C API binding.

  • Gopher – Lua – Lua 5.1 VM and compiler written in Go.

  • Gval – a highly customizable expression language written in Go.

  • Ngaro – Embeddable ngaro VM implementation that supports scripting in Retro.

  • Otto – a JavaScript interpreter written in Go.

  • Perl 5.18.2 embedded in Purl-go.

  • Tengo – a bytecode compilation scripting language for Go.

Error handling

  • Error handling tools and best practices for the Emperor-Go library and application.

  • Errlog – Breakable software package for responsible source code for determining errors (and some other quick debugging features). You can plug in any off-the-shelf logger.

  • Errors – Drop down to replace standard library error packages and github.com/pkg/errors. Provides various error handling primitives.

  • Errors – A package that provides simple error handling primitives.

  • Errors – Simple Golang error handling with classifiers.

  • Errorx – feature rich error package with stack trace, error composition, etc.

  • Falcon – a simple but powerful error handling software package.

  • Go-multierror-go (Golang) software package for representing a list of errors as a single error.

  • Tracerr – Golang error with stack trace and source code fragment.

  • The Werr – error wrapper creates a wrapper for the error type in Go that captures the file, line, and stack calling it.

file

  • Afero-go file system abstraction system.
  • Afs-go abstract file storage (MEM, SCP, ZIP, tar, cloud: S3, GS).
  • Bigfile – A file transfer system that supports file management using HTTP APIS, RPC calls and FTP clients.
  • Checksum – Computes message summaries for large files, such as MD5 and SHA256.
  • Flop – File manipulation library designed for parity with GNU CP mirroring features.
  • Go-csv-tag-tag – Loads CSV files using tags.
  • Go-decent -copy – Copies human files.
  • Go – ExifTool – The Go binding for exifTool, which is well known for libraries used to extract data from files (images, PDF, Office…) Extract as much metadata as possible (EXIF, IPTC, etc.).
  • Go – GTFS – Loads the GTFS file in GO.
  • Notify – file system event notification library with a simple API, similar to OS/Signal.
  • Opc – Loads the Open Packaging Conventions (OPC) file for Go.
  • Parquet – Reads and writes parquet files.
  • Pdfcpu-pdf processor.
  • Skywalker – a software package that allows a person to easily traverse the file system simultaneously.
  • STL – Module for reading and writing STL (stereo lithography) files. Concurrent read algorithm.
  • Tarfs-tar FileSystem interface implementation.
  • VFS – A set of pluggable, extensible, and self-righteous file system features for Go across multiple file system types (such as OS, S3, and GCS).

financial

  • Accounting-golang currency and currency format.
  • Currency – High performance and accurate currency calculation package.
  • Decimal – A fixed-point decimal number with arbitrary precision.
  • Comprehensive financial market data in go-finance-Go.
  • Go-finance – A library of financial functions for time value of money (annuity), cash flow, interest rate conversion, bonds and depreciation calculations.
  • Go-finance – module to get exchange rates, check VAT numbers and IBAN bank accounts over VIES.
  • Go-money-fowler the realization of the money model.
  • Ofxgo – Queries the OFX server and/or parses the response (using the example command line client).
  • Orderbook – Match engine limit order in Golang.
  • Techan – Technical analysis library with advanced market analysis and trading strategies.
  • Transaction – Embedded account running in multi-threaded mode embedded transaction database.
  • Vat-vat number verification and EU VAT rate.

The game development

  • Azul3D – 3D game engine written in Go language.
  • Ebiten-go dead simple 2D game library.
  • Engo – Engo is an open source 2D game engine written in Go. It follows the entity component system paradigm.
  • G3n-go 3D game engine.
  • GarageEngine – A 2D game engine written in Go and available on OpenGL.
  • Glop – Glop (Power Game Library) is a fairly simple cross-platform game library.
  • Go – ASTar – A go implementation of the path lookup algorithm.
  • Go-collada-go package, used for collada file format.
  • Go-sdl2 – Simple Go binding of DirectMedia Layer.
  • Go3d – Performance oriented 2D/3D math package for Go.
  • Gonet – A game server framework implemented using Golang.
  • Goworld – Scalable game server engine with spatial entity framework and hot plug capabilities.
  • Leaf – Lightweight game server framework.
  • Nano – Lightweight, high-performance Golang-based game server architecture.
  • Oak-pure Go game engine.
  • Pitaya – An extensible game server framework with clustering support and client libraries for iOS, Android, Unity and more via the C SDK.
  • A library of hand-crafted 2D games in Pixel-Go.
  • Raylib-go – Unbind Raylib, a simple and easy-to-use library to learn about video game programming.
  • Termloop-go’s terminal-based game engine, built on top of Termbox.

The geographical position

  • Geocache – In-memory caching for location-based applications.
  • Geoserver – GeoServer is a Go package for manipulating geoServer instances through the GeoServer REST API.
  • Gismanager – Publishes GIS data (vector data) to PostGIS and Geoserver.
  • Osm – A library for reading, writing, and using OpenStreetMap data and apis.
  • PBF – OpenStreetMap PBF GOLang encoder/decoder
  • S2 geometry library in S2 Geometry – Go.
  • Tile38 – Geo-location database with spatial index and real-time geo-fencing.
  • WGS84 – Library coordinate conversion and transformation (ETRS89, OSGB36, NAD83, RGF93, Network Mercator UTM).

The compiler

  • C4go – Converts C code to Go code.
  • F4go – Converts FORTRAN 77 code to Go code.
  • Gopherjs – Go to JavaScript compiler.
  • Llgo – LLVM based compiler for Go.
  • Tardisgo-golang converts to CPP/CSharp/Java/JavaScript translators.

Goroutines

  • Ants – High performance Goroutine pool for Golang.
  • Artifex-golang uses a simple in-memory job queue based on worker dispatch.
  • Async – a safe way to perform functions asynchronously, just in case.
  • Breaker – A flexible mechanism to make the execution process interruptible.
  • Cyclicbarrier – Cyclicbarrier for Golang.
  • Go – FLOc – Easily choreograph Goroutine.
  • Go-flow – Controls the execution order of goroutine.
  • Go-tools/Multithreading – Use lightweight libraries with simple apis to manage goroutine pools.
  • Go-trylock – A trylock that supports read/write locks for Golang.
  • Go-waitgroup-sync.waitgroup is similar to error handling and concurrency control.
  • Gohive-go’s high performance and easy to use Goroutine pool.
  • Gollback – Asynchronous simple function utility that manages the execution of closures and callbacks.
  • GoSlaves – Simple and asynchronous Goroutine pool library.
  • Goworker – Goworker is a go-based background worker.
  • Gowp – GOWp is the concurrent limit goroutine pool.
  • Gpool – Manages a resizable context-aware Goroutine pool to bind concurrency.
  • Grpool – Lightweight Goroutine pool.
  • Hunch – Hunch offers features such as: All, First, Retry, Waterfall and so on, which makes asynchronous flow control more intuitive.
  • Oversight – Oversight is a complete implementation of Erlang’s oversight tree.
  • Parallel-fn – Parallel running function.
  • Pool – Limited consumer Goroutine pool or unlimited Goroutine pool for easier processing and cancellation of Goroutine.
  • Queue – Gives you queue group accessibility similar to that of sync.waitGroup. Helps you throttle and limit goroutines, wait for all goroutines to end, and more.
  • Routine – Control routines with context and support: Main, Go, Pool and some useful Executors.
  • Semaphore – Channel – and context-based semaphore mode implementation with lock/unlock operation timeout.
  • Semaphore – Cas-based fast resizable semaphore implementation (faster than channel-based semaphore implementation).
  • STL – Software transaction lock based on software Transaction Memory (STM) concurrency control mechanism.
  • Threadpool-golang threadpool implementation.
  • Tunny – Thread pool golang.
  • The worker-pool-goworker is a simple Go asynchronous work pool.
  • Workerpool – Goroutine pool, which limits the concurrency of task execution rather than the number of queued tasks.

The graphical interface

  • App – a program packaged to create an application using GO, HTML, and CSS. Support: MacOS, Windows in development.
  • Fyne – Cross-platform native GUI for Go, using EFL rendering. Support: Linux, macOS, Windows.
  • Go – Astilectron – Build cross-platform GUI applications using GO and HTML/JS/CSS (supported by Electron).
  • Go-gtk-gtk binding.
  • Go-sciter-go binding: Embeddable HTML/CSS/Script engine for modern desktop UI development. Cross-platform.
  • Gotk3 – GTK3 binding.
  • Gowd – Quick and easy desktop UI development using GO, HTML, CSS and Nw.js. Cross-platform.
  • Qt-go qt binding (Windows/macOS/Linux/Android/iOS/Sailfish OS/Raspberry Pi)
  • Ui-go’s platform native GUI library. Cross-platform.
  • Wails – Mac, Windows, Linux desktop application with HTML UI using the built-in OS HTML renderer.
  • Walk-go’s Windows Application Library toolkit.
  • Webview – cross-platform WebView window (Windows/macOS/Linux) with simple bi-directional JavaScript binding.
  • Go – Appindicator – libappindicator3 C library go binding.
  • Gosx-notifier – Go Specifies the OSX desktop notification library.
  • The mac-activity-tracker-OSX library for notifying any (pluggable) activity on your computer.
  • OSX sleep/wake notification in mac-sleep-notifier – Golang.
  • Robotgo-go native cross-platform GUI system automation. Control mouse, keyboard, etc.
  • Systray – A cross-platform Go library for placing ICONS and menus in notification areas.
  • Trayhost – A cross-platform Go library for placing an icon in the taskbar of the host operating system.

The picture

  • Bild – A collection of image processing algorithms in pure Go.
  • Bimg – small packaging for fast and efficient image processing using Libvips.
  • Avatar generator for Cameron-Go.
  • Canvas – Converts vector graphics to PDF, SVG or raster images.
  • Darkroom – Image agent with variable storage back end and image processing engine that focuses on speed and elasticity.
  • Geopattern – Creates beautiful generated image patterns from strings.
  • Gg – 2D rendering in Pure Go.
  • Gift – Packaging for image processing filters.
  • GLTF – Efficient, powerful GLTF 2.0 reader, writer and validator.
  • Go – Cairo – Used for binding Cairo graphics libraries.
  • Go-gd-go binding for the GD library.
  • Nude detection of Go-nude-Go.
  • Go-opencv – Used for opencV binding.
  • Go-webcolors – Port of the Webcolors library, from Python to Go.
  • Gocv – Go software package for computer vision using OpenCV 3.3+.
  • Goimagehash-go senses imagehash packets.
  • Goimghdr – The imGHDR module determines the type of image contained in the Go file.
  • Govatar – Library and CMD tool for generating interesting avatars.
  • Image2ascii – Converts an image to ASCII.
  • Imagick – MagickWand C API bound to ImageMagick.
  • Imaginary – Fast, simple HTTP microservice for image resizing.
  • Imaging – Simple Go image processing package.
  • Img – Selects the image processing tool.
  • 3D line art rendering in LN-Go.
  • Mergi – Tool&Go library for image processing (merge, crop, resize, watermark, animation).
  • Mort – Storage and image processing server written in Go.
  • Mpo – Decoder and conversion tool for MPO 3D photos.
  • Picfit – Image resizing server written with Go.
  • Pt – Path tracking engine written in Go language.
  • Resize – Resizes the image for Go using a common interpolation method.
  • Rez – Resizes images in pure Go and SIMD.
  • Smartcrop – Find quality crops that fit any image and size.
  • Steganography – Pure Go library for LSB steganography.
  • Stegify – Go tool for LSB steganography, able to hide any file in an image.
  • Svgo – Go language library for SVG generation.
  • Tga – Software package TGA is a decoder/encoder for the TARGA image format.

The Internet of things

  • Connectordb – Open source platform for quantifying self and the Internet of Things.
  • Devices-iot device library suite, for x/EXP/IO experiments.
  • Eywa – Project EyWA is essentially a connection manager that keeps track of connected devices.
  • Flogo – Project Flogo is an open source framework for IoT Edge applications and integration.
  • Gatt-gate is a Go package built with low power Bluetooth peripherals.
  • Gobot – Gobot is a framework for robotics, physical computing and the Internet of Things.
  • Huego – Philips Hue extension client library for Go.
  • Iot – iot is a simple framework for implementing Google iot Core devices.
  • Mainflux – Industrial Iot messaging and device management server.
  • Periph – Peripherals I/O interface with low-level motherboard devices.
  • Sensorbee – Lightweight flow processing engine for the Internet of Things.

JSON format

  • Ajson – Abstract JSON for Golang with JSONPath support.
  • Gjo – a small utility for creating JSON objects.
  • GJSON – Gets the JSON value with a single line of code.
  • Go-jsonerror-go-jsonerror makes it easy to create JSON response errors that follow the Json API specification.
  • Go-respond-go package, which processes common HTTP JSON responses.
  • JSON query in gojq-golang.
  • Gojson – Automatically generates Go (Golang) structure definitions from sample JSON.
  • JayDiff – JSON diff utility written in Go.
  • Jettison – High performance, non-reflective JSON encoder for Go.
  • Json-to-go – Converts JSON to a Go structure.
  • Json2go – Advanced JSON to Go structure conversion. Provides packages that parse multiple JSON documents and create structures that fit all JSON.
  • Jsonapi-errors – Binds according to JSON API error references.
  • Jsonf – Console tool for highlighting formatting and retrieving JSON structure queries.
  • The JsonGo-Fluent API makes it easier to create Json objects.
  • Jsonhal – Simple Go package for marshalling custom structures into HAL-compatible JSON responses.
  • Kazaam – API for arbitrary conversion of JSON documents.
  • Mp – Simple CLI email parser. Currently, it uses standard input and outputs JSON.

Machine learning

  • Bayesian classification is called Golang naivete.
  • CloudForest – Fast, flexible, multi-threaded decision tree collection for machine learning in pure Go.
  • Eaopt – Evolutionary optimization library.
  • Evoli – Library for Genetic Algorithms and particle swarm optimization.
  • Fonet – Deep neural network library written in Go.
  • Go implementation of Go-Cluster-K mode and K-prototype clustering algorithm.
  • Go-deep-go rich neural network library
  • Go-fann – The Go binding of the fast Artificial neural network (FANN) library.
  • Go – Galib – A library of genetic algorithms written by GO/Golang.
  • Pattern recognition package in go-pr-Go lang.
  • Gobrain – Neural network written in the GO language
  • Godist – Various probability distributions and related methods.
  • Library of genetic algorithms for Goga-Go.
  • GoLearn – A general purpose machine learning library for Go.
  • Golinear-go’s Liblinear binding.
  • A simple neural network library in Gomind-Go.
  • Online machine learning in Goml-Go.
  • Goptuna – A Bayesian optimization framework for black box functions written in Go. Everything will be optimized.
  • GoRecommend – a library of recommended algorithms written in Go.
  • Gorgonia – Graph-based computing libraries, such as Theano for Go, which provide primitives for building various machine learning and neural network algorithms.
  • Gorse – An offline recommendation system backend for collaborative filtering written based on Go.
  • Goscore – Go Scoring API for PMML.
  • Gosseract – OCR (Optical Character Recognition) software package using Tesseract C ++ library.
  • Libsvm – golang based on libSVM 3.14 libSVM.
  • Neat – A plug-and-play, parallel Go framework for enhancing topological neural evolution (NEAT).
  • Neural – go-go – Multi-layer perceptron network implemented in GO, trained by back propagation.
  • Ocrserver – a simple OCR API server that is easily deployed by Docker and Heroku.
  • Onnx-go – Go to the interface of open Neural Network Switching (ONNX).
  • Probab – Probability distribution function. Bayesian inference. Written in pure Go.
  • Regommend – Advice and collaborative filtering engine.
  • Shield-bayesian text classifier with flexible marker and Go storage back end.
  • Tfgo – Easy to use Tensorflow binding: Simplifies the use of the official Tensorflow Go binding. Define the computation diagram in Go, load and execute the Python-trained model.
  • Varis-golang neural network.

financial

  • Unioffice-pure Go library for creating and processing Office Word (.docx), Excel (.xlsx) and Powerpoint (.pptx) documents.
  • The Excelize-Golang library is used for reading and writing Microsoft Excel™ (XLSX) files.
  • Go-excel – a simple and lightweight reader that reads Excel like related- DB into tables.
  • Goxlsxwriter – Golang binding of libxlsxwriter, used to write XLSX (Microsoft Excel) files.
  • XLSX – A library to simplify reading the XML format used in the latest version of Microsoft Excel in Go programs.
  • XLSX – A quick/safe way to read/update your existing Microsoft Excel files in the Go program.

Natural language processing

  • Getlang – Fast natural language detection package.
  • Go – I18N – Software package for handling localized text and an accompanying tool.
  • Go – MySTEM – CGo and Yandex.Mystem binding – Russian morphology analyzer.
  • Go-nlp – Utilities for handling discrete probability distributions and other tools that can be used to perform NLP work.
  • Go -pinyin – CN Hanzi to Hanyu Pinyin converter
  • The Go-STEM – porter prevents the implementation of the algorithm.
  • Go-unidecode – ASCII transliteration of Unicode text.
  • Go2vec – Reader and utility features for word2vec embedding.
  • Gojieba – This is a Go implementation to solve hegemony in which the Chinese word segmentation algorithm.
  • Golibstemmer – Binding of the snowball library libstemmer library, including Porter 2.
  • Gotokenizer – A marker for the Bigram language model based on dictionaries and Goram. (Now only support Chinese segmentation)
  • Gounidecode-go’s Unicode transliterator (also known as unidecode).
  • Gse – Effective text segmentation; Support English, Chinese, Japanese, etc.
  • Icu – CGO combines detection and conversion capabilities for the ICU4C C library. Guaranteed compatibility with version 50.1.
  • Kagome – JP morphology analyzer written in pure Go language.
  • Libtextcat – Cgo binding of libtextCat C library. Guaranteed compatibility with version 2.2.
  • MMSEGO – This is the GO implementation of MMSEG, which is the Chinese word segmentation algorithm.
  • NLP – Extract values from strings and populate your structure with NLP.
  • NLP – A natural language processing library that supports LSA (latent semantic analysis).
  • Golang implementation of PaiceHusk – Paice/Husk extraction algorithm.
  • Petrovich is a library that uses the Russian name for a given grammatical case.
  • Porter – This is a fairly simple port of the C implementation of Martin Porter’s Porter stem algorithm.
  • Porter 2 – Very fast Porter 2 extractor.
  • Transcended – a library for text processing, supporting tokenization, part of speech tagging, named entity extraction, etc. English only.
  • RAKE. Go – Go port for fast automatic Keyword Extraction Algorithm (RAKE).
  • Segment – The Go library for performing Unicode text segments as described in Annex # 29 to the Unicode standard
  • Sentences – Sentence marker: Converts text to a list of sentences.
  • Shamoji – Shamoji is a word filter package written in Go.
  • Snowball-go snow bulb port (CGO wrapper). Provides word stem extraction function Snowball machine.
  • Stemmer – Stemmer package for the Go programming language. Includes English and German stems.
  • Textcat-go software package for N-gram based text classification and supports UTF-8 and raw text.
  • Whatlanggo-go’s natural language detection package. Supports 84 languages and 24 scripts (writing systems such as Latin, Cyrillic, etc.).
  • When – Natural EN and RU language date/time analyzers have pluggable rules.

network

  • Arp – Packet ARP implements the ARP protocol, as described in RFC 826.

  • Buffstreams – Buffering data via TCP streams protocol is made easier.

  • Canopus-coap client/server implementation (RFC 7252).

  • Cidrange-go fast IP to CIDR lookup.

  • Dhcp6 – The package DHCP6 implements the DHCPv6 server, as described in RFC 3315.

  • DNS – Use the Go library for DNS.

  • Ether – A cross-platform Go package for sending and receiving Ethernet frames.

  • Ethernet – Program package Ethernet implements the encapsulation of IEEE 802.3ETHERNET II frames and IEEE 802.1Q VLAN tags.

  • Fasthttp – software package fasthttp is a fasthttp implementation of Go, 10 times faster than net/HTTP.

  • Fortio – Load test library and command line tools, advanced echo server and Web UI. Allows you to specify a set query load per second and to record and graph delay histograms and other useful statistics. Tcp, Http, gRPC.

  • FTP – Package FTP implements the FTP client as described in RFC 959.

  • Gev – GEV is a lightweight, fast, non-blocking TCP network library based on the Reactor pattern.

  • GMQTT – GMQTT is a flexible, high-performance MQTT broker library that fully implements the MQTT protocol V3.1.1.

  • Gnet – GNET is a high-performance, portable, non-blocking, event loop network library for pure Go.

  • GNxI – a collection of network management tools using gNMI and gNOI protocols.

  • Go-getter-go library for downloading files or directories from various sources using urls.

  • Go-powerdns-golang powerDNS API binding.

  • Go implementation of go-stun-STUn client (RFC 3489 and RFC 5389).

  • Gobgp – BGP implemented using the Go programming language.

  • Golibwireshark – Software package GolibWireshark uses the libWireshark library to decode PCAP files and analyze anatomical data.

  • The gopacket-go library for packet processing using the libpcap binding.

  • Gopcap-libpcap wrapper.

  • Goshark – Software package Goshark uses Tshark to decode IP packets and create data structures to analyze packets.

  • Gosnmp – A native Go library for performing SNMP operations.

  • Gosocsvr – Socket server becomes simple.

  • Gotcp – Go software package for quickly writing TCP applications.

  • Grab – Software package for managing file downloads.

  • Graval – Experimental FTP server framework.

  • HTTPLab – HTTPLabs lets you examine HTTP requests and forge responses.

  • Iplib – library inspired by Python ipAddress and Ruby ipaddr to use IP addresses (net.IP, net.ipnet)

  • Jazigo – Jazigo is a tool written in the Go language for retrieving the configuration of multiple network devices.

  • Kcp-go – KCP- Fast and reliable ARQ protocol.

  • Kcptun – extremely simple and fast UDP tunnel based on KCP protocol.

  • LHTTP – powerful Websocket framework to make it easier to build IM servers.

  • Linkio – Network link speed simulation for the reader/writer interface.

  • LLB – This is a very simple but fast back end to a proxy server. Fast redirection to predefined domains is useful for zero memory allocation and fast response.

  • Simple MDNS (multicast DNS) client/server library in MDNS-Golang.

  • The mqttPaho – Paho Go client provides an MQTT client library for connecting to an MQTT proxy over TCP, TLS, or WebSockets.

  • Nff-go – a framework for rapid development of high performance networking capabilities for cloud and bare metal machines (formerly YANFF).

  • Packet – Sends packets through TCP and UDP. It can buffer messages and heat exchange connections if needed.

  • Peerdiscovery-pure Go library for cross-platform local peerdiscovery using UDP multicast.

  • Portproxy – a simple TCP proxy that adds apis that do not support it to CORS support.

  • Publicip – The package publicIP returns your public-facing IPv4 address (Internet exit).

  • Quic-go – Implements the QUIC protocol in pure GO.

  • Raw – The raw package allows data to be read and written to the network interface at the device driver level.

  • SFTP – Program package SFTP Implements SSH file transfer protocols, such as filezilla-project.org/specs/draft…

  • SSH – A high-level API for building SSH servers (wrapped crypto/SSH).

  • SSLB – This is a super simple load balancer, just a small project to achieve some performance.

  • Stun – Implements THE RFC 5389 STUN protocol.

  • Tcp_server – Go library for faster construction of TCP servers.

  • The TSpool-TCP library uses working pools to improve performance and protect your server.

  • Implementation of UTP – Go UTP microtransmission protocol.

  • Water – Simple TUN/TAP library.

  • Webrtc – A pure Go implementation of the WebrTC API.

  • Winrm – Enter the Winrm client to execute commands remotely on a Windows computer.

  • XTCP – TCP Server Framework with synchronous full-duplex communication, secure shutdown, and custom protocols.

video

  • Go-astisub – Process subtitles in GO (.srt,.stl,.ttml,.webvtt,.ssa /.ass, Teletext,.smi, etc.).

  • Go – AStits – Locally parses and demultiplexes MPEG transport streams (.ts) in GO.

  • Go – M3U8 – Apple M3U8 playlist parser and generator library.

  • Comprehensive Go binding for GOAV-FFmPEG.

  • Gst-gstreamer binding.

  • Subtitle format support by libgosubs-Go. SRT,.ttml, and.ass are supported.

  • Libvlc-go-libvlc 2.X / 3.X / 4.X binding (used by VLC media player).

  • M3u8 – Apple HLS’s m3U8 playlist parser and generator library.

  • V4l – Linux video capture library written in Go.

Open source books

  • Go PalyGround – Code Go online without setting up a local Go environment

  • Go Hands-on development – The author is the author of the famous Go open source project Beego, and his best practices are well worth reading

  • Go Web Programming – same author as the previous book on Web development

  • Go language standard library – An introduction to the standard library

  • Go starter guide – suitable for beginners, the content is relatively basic

  • Go Language Bible – Book as its name suggests

  • Go language Chinese – Find the right circle, learn faster

  • Novice Tutorial – this site is great for getting up to speed on a language

  • Go language advanced programming – content suitable for advanced

  • Go language originally – Oushen production, although the alleged progress of only 9.9%/100%, but does not hinder its excellent, worth a look

  • Golang Design Mode – Golang implementation of Design Mode, Golang implementation of Grinding Design Mode

  • Go Language Chapter 42 – Can be compared to fill gaps

Video online classes

External chain problem, go to github project for yourself hahaha.