Go Goroutines

Open-source Go projects categorized as Goroutines

Top 23 Go Goroutine Projects

  • ants

    🐜🐜🐜 ants is a high-performance and low-cost goroutine pool in Go./ ants 是一个高性能且低损耗的 goroutine 池。

    Project mention: Rust vs Go Issue | /r/rust | 2023-04-04

    I remember doing something similar to OP recently. Goroutines also incur a bit of overhead (have to be GC'd and so on), and the same worker pool technique can be applied to them in much the same way, as seen in popular libraries like https://github.com/panjf2000/ants

  • conc

    Better structured concurrency for go

    Project mention: Go CLI to calculate total media duraton in directories | news.ycombinator.com | 2023-09-04

    What are possible use cases for this tool? Why would I want to find out the total runtime of all videos in a directory?

    Also, you might wanna limit concurrency[0] instead of spawning many ffprobe instances at the ~same time.

    [0]: https://github.com/sourcegraph/conc

    In another note, ChatGPT suggests this shell command to do the same thing. It doesn't process files in parallel though.

        find . -name "*.mp4" -print0 | \

  • Mergify

    Updating dependencies is time-consuming.. Solutions like Dependabot or Renovate update but don't merge dependencies. You need to do it manually while it could be fully automated! Add a Merge Queue to your workflow and stop caring about PR management & merging. Try Mergify for free.

  • tunny

    A goroutine pool for Go

    Project mention: Help! channel vs workerpool | /r/golang | 2023-02-24

    https://github.com/Jeffail/tunny uses interface, os it's a no for me

  • goworker

    goworker is a Go-based background worker that runs 10 to 100,000* times faster than Ruby-based workers.

  • pond

    🔘 Minimalistic and High-performance goroutine worker pool written in Go

    Project mention: Help! channel vs workerpool | /r/golang | 2023-02-24

    https://github.com/alitto/pond i use this one :3

  • grpool

    Lightweight Goroutine pool

  • pool

    :speedboat: a limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation

  • SonarLint

    Clean code begins in your IDE with SonarLint. Up your coding game and discover issues early. SonarLint is a free plugin that helps you find & fix bugs and security issues from the moment you start writing code. Install from your favorite IDE marketplace today.

  • gowp

    golang worker pool , Concurrency limiting goroutine pool

  • go-floc

    Floc: Orchestrate goroutines with ease.

  • Goflow

    Simply way to control goroutines execution order based on dependencies

  • artifex

    Simple in-memory job queue for Golang using worker-based dispatching

  • flowmatic

    Structured concurrency made easy

    Project mention: Async rust – are we doing it all wrong? | news.ycombinator.com | 2023-07-19

    I do that of course, and that's one of the easiest ways to use async Rust. In real projects you need much more however. F.ex. I had to code an example of how to add tasks to an already running pool of tasks and posted my findings here: https://github.com/dimitarvp/rust-async-examples/blob/main/e... (there's #2 as well with some more comments and a different approach).

    The fact that I needed to make a GitHub repo and start making show-and-tell demos on how to do various things with async Rust to me is both a red flag and me being diligent BUT it should be more obvious. And promoted in docs.

    Rust started suffering from "you got all the nuts and bolts in place, now build your own solution, son" syndrome which I grew to dislike. Too low-level. I wouldn't mind something akin to e.g. Golang's flowmatic library (check the first two examples at the top of the README): https://github.com/carlmjohnson/flowmatic

  • semaphore go

    Fast resizable golang semaphore primitive (by marusama)

  • go-workers

    👷 Library for safely running groups of workers concurrently or consecutively that require input and output through channels

  • neilotoole/errgroup

    errgroup with goroutine worker limits

  • roumon

    Universal goroutine monitor using pprof and termui

  • broadcast

    Notification broadcaster library

  • cyclicbarrier

    CyclicBarrier golang implementation

  • async

    A safe way to execute functions asynchronously, recovering them in case of panic. It also provides an error stack aiming to facilitate fail causes discovery. (by StudioSol)

  • Syncs

    Concurrency and synchronization primitives

  • gollback

    Go asynchronous simple function utilities, for managing execution of closures and callbacks

  • semaphore

    🚦 Semaphore pattern implementation with timeout of lock/unlock operations. (by kamilsk)

  • Hunch

    Hunch provides functions like: All, First, Retry, Waterfall etc., that makes asynchronous flow control more intuitive.

  • InfluxDB

    Collect and Analyze Billions of Data Points in Real Time. Manage all types of time series data in a single, purpose-built database. Run at any scale in any environment in the cloud, on-premises, or at the edge.

NOTE: The open source projects on this list are ordered by number of github stars. The number of mentions indicates repo mentiontions in the last 12 Months or since we started tracking (Dec 2020). The latest post mention was on 2023-09-04.

Go Goroutines related posts


What are some of the best open-source Goroutine projects in Go? This list will help you:

Project Stars
1 ants 11,048
2 conc 7,284
3 tunny 3,689
4 goworker 2,740
5 pond 988
6 grpool 732
7 pool 720
8 gowp 480
9 go-floc 262
10 Goflow 214
11 artifex 178
12 flowmatic 171
13 semaphore go 161
14 go-workers 159
15 neilotoole/errgroup 151
16 roumon 150
17 broadcast 130
18 cyclicbarrier 125
19 async 125
20 Syncs 115
21 gollback 111
22 semaphore 96
23 Hunch 95
Collect and Analyze Billions of Data Points in Real Time
Manage all types of time series data in a single, purpose-built database. Run at any scale in any environment in the cloud, on-premises, or at the edge.