Logo

0x5a.live

for different kinds of informations and explorations.

GitHub - gagliardetto/solana-go: Go SDK library and RPC client for the Solana Blockchain

Go SDK library and RPC client for the Solana Blockchain - gagliardetto/solana-go

Visit SiteGitHub - gagliardetto/solana-go: Go SDK library and RPC client for the Solana Blockchain

GitHub - gagliardetto/solana-go: Go SDK library and RPC client for the Solana Blockchain

Go SDK library and RPC client for the Solana Blockchain - gagliardetto/solana-go

Powered by 0x5a.live 💗

Solana SDK library for Go

GoDoc GitHub tag (latest SemVer pre-release) Build Status TODOs Go Report Card

Go library to interface with Solana JSON RPC and WebSocket interfaces.

More contracts to come.

If you're using/developing Solana programs written in Anchor Framework, you can use anchor-go to generate Golang clients

If you're looking for a SERUM library, you can check out gagliardetto/serum-go (./programs/serum is deprecated.)

Future Development

solana-go is exclusively supported by my own time (which is money).

If my work has been useful in building your for-profit services/infra/bots/etc., consider donating at 8tTwBazKr2ST1b2kNrM7JMXwixRTvZicn7eRBihThymm (solana) to support future development.

Thanks!

Contents

Features

  • Full JSON RPC API
  • Full WebSocket JSON streaming API
  • Wallet, account, and keys management
  • Clients for native programs
    • system
    • config
    • stake
    • vote
    • BPF Loader
    • Secp256k1
  • Clients for Solana Program Library (SPL)
  • Client for Serum
  • Metaplex:
    • auction
    • metaplex
    • token-metadata
    • token-vault
    • nft-candy-machine
  • More programs

Current development status

There is currently no stable release. The SDK is actively developed and latest is v1.12.0 which is an alpha release.

The RPC and WS client implementation is based on this RPC spec.

Note

  • solana-go is in active development, so all APIs are subject to change.
  • This code is unaudited. Use at your own risk.

Requirements

  • Go 1.19 or later

Installation

$ cd my-project
$ go get github.com/gagliardetto/[email protected]

Pretty-Print transactions/instructions

pretty-printed

Instructions can be pretty-printed with the String() method on a Transaction:

tx, err := solana.NewTransaction(
  []solana.Instruction{
    system.NewTransferInstruction(
      amount,
      accountFrom.PublicKey(),
      accountTo,
    ).Build(),
  },
  recent.Value.Blockhash,
  solana.TransactionPayer(accountFrom.PublicKey()),
)

...

// Pretty print the transaction:
fmt.Println(tx.String())
// OR you can choose a destination and a title:
// tx.EncodeTree(text.NewTreeEncoder(os.Stdout, "Transfer SOL"))

SendAndConfirmTransaction

You can wait for a transaction confirmation using the github.com/gagliardetto/solana-go/rpc/sendAndConfirmTransaction package tools (for a complete example: see here)

// Send transaction, and wait for confirmation:
sig, err := confirm.SendAndConfirmTransaction(
  context.TODO(),
  rpcClient,
  wsClient,
  tx,
)
if err != nil {
  panic(err)
}
spew.Dump(sig)

The above command will send the transaction, and wait for its confirmation.

Address Lookup Tables

Resolve lookups for a transaction:

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/davecgh/go-spew/spew"
	"github.com/gagliardetto/solana-go"
	lookup "github.com/gagliardetto/solana-go/programs/address-lookup-table"
	"github.com/gagliardetto/solana-go/rpc"
	"golang.org/x/time/rate"
)

func main() {
	cluster := rpc.MainNetBeta

	rpcClient := rpc.NewWithCustomRPCClient(rpc.NewWithLimiter(
		cluster.RPC,
		rate.Every(time.Second), // time frame
		5,                       // limit of requests per time frame
	))

	version := uint64(0)
	tx, err := rpcClient.GetTransaction(
		context.Background(),
		solana.MustSignatureFromBase58("24jRjMP3medE9iMqVSPRbkwfe9GdPmLfeftKPuwRHZdYTZJ6UyzNMGGKo4BHrTu2zVj4CgFF3CEuzS79QXUo2CMC"),
		&rpc.GetTransactionOpts{
			MaxSupportedTransactionVersion: &version,
			Encoding:                       solana.EncodingBase64,
		},
	)
	if err != nil {
		panic(err)
	}
	parsed, err := tx.Transaction.GetTransaction()
	if err != nil {
		panic(err)
	}
	processTransactionWithAddressLookups(parsed, rpcClient)
}

func processTransactionWithAddressLookups(txx *solana.Transaction, rpcClient *rpc.Client) {
	if !txx.Message.IsVersioned() {
		fmt.Println("tx is not versioned; only versioned transactions can contain lookups")
		return
	}
	tblKeys := txx.Message.GetAddressTableLookups().GetTableIDs()
	if len(tblKeys) == 0 {
		fmt.Println("no lookup tables in versioned transaction")
		return
	}
	numLookups := txx.Message.GetAddressTableLookups().NumLookups()
	if numLookups == 0 {
		fmt.Println("no lookups in versioned transaction")
		return
	}
	fmt.Println("num lookups:", numLookups)
	fmt.Println("num tbl keys:", len(tblKeys))
	resolutions := make(map[solana.PublicKey]solana.PublicKeySlice)
	for _, key := range tblKeys {
		fmt.Println("Getting table", key)

		info, err := rpcClient.GetAccountInfo(
			context.Background(),
			key,
		)
		if err != nil {
			panic(err)
		}
		fmt.Println("got table "+key.String())

		tableContent, err := lookup.DecodeAddressLookupTableState(info.GetBinary())
		if err != nil {
			panic(err)
		}

		fmt.Println("table content:", spew.Sdump(tableContent))
		fmt.Println("isActive", tableContent.IsActive())

		resolutions[key] = tableContent.Addresses
	}

	err := txx.Message.SetAddressTables(resolutions)
	if err != nil {
		panic(err)
	}

	err = txx.Message.ResolveLookups()
	if err != nil {
		panic(err)
	}
	fmt.Println(txx.String())
}

Parse/decode an instruction from a transaction

package main

import (
  "context"
  "encoding/base64"
  "os"
  "reflect"

  "github.com/davecgh/go-spew/spew"
  bin "github.com/gagliardetto/binary"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/programs/system"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/text"
)

func main() {
  exampleFromGetTransaction()
}

func exampleFromBase64() {
  encoded := "AfjEs3XhTc3hrxEvlnMPkm/cocvAUbFNbCl00qKnrFue6J53AhEqIFmcJJlJW3EDP5RmcMz+cNTTcZHW/WJYwAcBAAEDO8hh4VddzfcO5jbCt95jryl6y8ff65UcgukHNLWH+UQGgxCGGpgyfQVQV02EQYqm4QwzUt2qf9f1gVLM7rI4hwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6ANIF55zOZWROWRkeh+lExxZBnKFqbvIxZDLE7EijjoBAgIAAQwCAAAAOTAAAAAAAAA="

  data, err := base64.StdEncoding.DecodeString(encoded)
  if err != nil {
    panic(err)
  }

  // parse transaction:
  tx, err := solana.TransactionFromDecoder(bin.NewBinDecoder(data))
  if err != nil {
    panic(err)
  }

  decodeSystemTransfer(tx)
}

func exampleFromGetTransaction() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  txSig := solana.MustSignatureFromBase58("3hZorctJtD3QLCRV3zF6JM6FDbFR5kAvsuKEG1RH9rWdz8YgnDzAvMWZFjdJgoL8KSNzZnx7aiExm1JEMC8KHfyy")
  {
    out, err := client.GetTransaction(
      context.TODO(),
      txSig,
      &rpc.GetTransactionOpts{
        Encoding: solana.EncodingBase64,
      },
    )
    if err != nil {
      panic(err)
    }

    tx, err := solana.TransactionFromDecoder(bin.NewBinDecoder(out.Transaction.GetBinary()))
    if err != nil {
      panic(err)
    }

    decodeSystemTransfer(tx)
  }
}

func decodeSystemTransfer(tx *solana.Transaction) {
  spew.Dump(tx)

  // Get (for example) the first instruction of this transaction
  // which we know is a `system` program instruction:
  i0 := tx.Message.Instructions[0]

  // Find the program address of this instruction:
  progKey, err := tx.ResolveProgramIDIndex(i0.ProgramIDIndex)
  if err != nil {
    panic(err)
  }

  // Find the accounts of this instruction:
  accounts, err := i0.ResolveInstructionAccounts(&tx.Message)
  if err != nil {
    panic(err)
  }

  // Feed the accounts and data to the system program parser
  // OR see below for alternative parsing when you DON'T know
  // what program the instruction is for / you don't have a parser.
  inst, err := system.DecodeInstruction(accounts, i0.Data)
  if err != nil {
    panic(err)
  }

  // inst.Impl contains the specific instruction type (in this case, `inst.Impl` is a `*system.Transfer`)
  spew.Dump(inst)
  if _, ok := inst.Impl.(*system.Transfer); !ok {
    panic("the instruction is not a *system.Transfer")
  }

  // OR
  {
    // There is a more general instruction decoder: `solana.DecodeInstruction`.
    // But before you can use `solana.DecodeInstruction`,
    // you must register a decoder for each program ID beforehand
    // by using `solana.RegisterInstructionDecoder` (all solana-go program clients do it automatically with the default program IDs).
    decodedInstruction, err := solana.DecodeInstruction(
      progKey,
      accounts,
      i0.Data,
    )
    if err != nil {
      panic(err)
    }
    // The returned `decodedInstruction` is the decoded instruction.
    spew.Dump(decodedInstruction)

    // decodedInstruction == inst
    if !reflect.DeepEqual(inst, decodedInstruction) {
      panic("they are NOT equal (this would never happen)")
    }

    // To register other (not yet registered decoders), you can add them with
    // `solana.RegisterInstructionDecoder` function.
  }

  {
    // pretty-print whole transaction:
    _, err := tx.EncodeTree(text.NewTreeEncoder(os.Stdout, text.Bold("TEST TRANSACTION")))
    if err != nil {
      panic(err)
    }
  }
}

Borsh encoding/decoding

You can use the github.com/gagliardetto/binary package for encoding/decoding borsh-encoded data:

Decoder:

  resp, err := client.GetAccountInfo(
    context.TODO(),
    pubKey,
  )
  if err != nil {
    panic(err)
  }

  borshDec := bin.NewBorshDecoder(resp.GetBinary())
  var meta token_metadata.Metadata
  err = borshDec.Decode(&meta)
  if err != nil {
    panic(err)
  }

Encoder:

buf := new(bytes.Buffer)
borshEncoder := bin.NewBorshEncoder(buf)
err := borshEncoder.Encode(meta)
if err != nil {
  panic(err)
}
// fmt.Print(buf.Bytes())

ZSTD account data encoding

You can request account data to be encoded with base64+zstd in the Encoding parameter:

resp, err := client.GetAccountInfoWithOpts(
  context.TODO(),
  pubKey,
  &rpc.GetAccountInfoOpts{
    Encoding:   solana.EncodingBase64Zstd,
    Commitment: rpc.CommitmentFinalized,
  },
)
if err != nil {
  panic(err)
}
spew.Dump(resp)

var mint token.Mint
err = bin.NewDecoder(resp.GetBinary()).Decode(&mint)
if err != nil {
  panic(err)
}
spew.Dump(mint)

Working with rate-limited RPC providers

package main

import (
  "context"

  "golang.org/x/time/rate"
  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  cluster := rpc.MainNetBeta
  client := rpc.NewWithCustomRPCClient(rpc.NewWithLimiter(
		cluster.RPC,
		rate.Every(time.Second), // time frame
		5,                       // limit of requests per time frame
	))

  out, err := client.GetVersion(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

Custom Headers for authenticating with RPC providers

package main

import (
  "context"

  "golang.org/x/time/rate"
  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  cluster := rpc.MainNetBeta
  client := rpc.NewWithHeaders(
    cluster.RPC,
    map[string]string{
      "x-api-key": "...",
    },
  )

  out, err := client.GetVersion(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

The data will AUTOMATICALLY get decoded and returned (the right decoder will be used) when you call the resp.GetBinary() method.

Timeouts and Custom HTTP Clients

You can use a timeout context:

ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
defer cancel()
acc, err := rpcClient.GetAccountInfoWithOpts(
  ctx,
  accountID,
  &rpc.GetAccountInfoOpts{
    Commitment: rpc.CommitmentProcessed,
  },
)

Or you can initialize the RPC client using a custom HTTP client using rpc.NewWithCustomRPCClient:

import (
  "net"
  "net/http"
  "time"

  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/rpc/jsonrpc"
)

func NewHTTPTransport(
  timeout time.Duration,
  maxIdleConnsPerHost int,
  keepAlive time.Duration,
) *http.Transport {
  return &http.Transport{
    IdleConnTimeout:     timeout,
    MaxIdleConnsPerHost: maxIdleConnsPerHost,
    Proxy:               http.ProxyFromEnvironment,
    Dial: (&net.Dialer{
      Timeout:   timeout,
      KeepAlive: keepAlive,
    }).Dial,
  }
}

// NewHTTP returns a new Client from the provided config.
func NewHTTP(
  timeout time.Duration,
  maxIdleConnsPerHost int,
  keepAlive time.Duration,
) *http.Client {
  tr := NewHTTPTransport(
    timeout,
    maxIdleConnsPerHost,
    keepAlive,
  )

  return &http.Client{
    Timeout:   timeout,
    Transport: tr,
  }
}

// NewRPC creates a new Solana JSON RPC client.
func NewRPC(rpcEndpoint string) *rpc.Client {
  var (
    defaultMaxIdleConnsPerHost = 10
    defaultTimeout             = 25 * time.Second
    defaultKeepAlive           = 180 * time.Second
  )
  opts := &jsonrpc.RPCClientOpts{
    HTTPClient: NewHTTP(
      defaultTimeout,
      defaultMaxIdleConnsPerHost,
      defaultKeepAlive,
    ),
  }
  rpcClient := jsonrpc.NewClientWithOpts(rpcEndpoint, opts)
  return rpc.NewWithCustomRPCClient(rpcClient)
}

Examples

Create account (wallet)

package main

import (
  "context"
  "fmt"

  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  // Create a new account:
  account := solana.NewWallet()
  fmt.Println("account private key:", account.PrivateKey)
  fmt.Println("account public key:", account.PublicKey())

  // Create a new RPC client:
  client := rpc.New(rpc.TestNet_RPC)

  // Airdrop 1 SOL to the new account:
  out, err := client.RequestAirdrop(
    context.TODO(),
    account.PublicKey(),
    solana.LAMPORTS_PER_SOL*1,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  fmt.Println("airdrop transaction signature:", out)
}

Load/parse private and public keys

{
  // Load private key from a json file generated with
  // $ solana-keygen new --outfile=standard.solana-keygen.json
  privateKey, err := solana.PrivateKeyFromSolanaKeygenFile("/path/to/standard.solana-keygen.json")
  if err != nil {
    panic(err)
  }
  fmt.Println("private key:", privateKey.String())
  // To get the public key, you need to call the `PublicKey()` method:
  publicKey := privateKey.PublicKey()
  // To get the base58 string of a public key, you can call the `String()` method:
  fmt.Println("public key:", publicKey.String())
}

{
  // Load private key from base58:
  {
    privateKey, err := solana.PrivateKeyFromBase58("66cDvko73yAf8LYvFMM3r8vF5vJtkk7JKMgEKwkmBC86oHdq41C7i1a2vS3zE1yCcdLLk6VUatUb32ZzVjSBXtRs")
    if err != nil {
      panic(err)
    }
    fmt.Println("private key:", privateKey.String())
    fmt.Println("public key:", privateKey.PublicKey().String())
  }
  // OR:
  {
    privateKey := solana.MustPrivateKeyFromBase58("66cDvko73yAf8LYvFMM3r8vF5vJtkk7JKMgEKwkmBC86oHdq41C7i1a2vS3zE1yCcdLLk6VUatUb32ZzVjSBXtRs")
    _ = privateKey
  }
}

{
  // Generate a new key pair:
  {
    privateKey, err := solana.NewRandomPrivateKey()
    if err != nil {
      panic(err)
    }
    _ = privateKey
  }
  {
    { // Generate a new private key (a Wallet struct is just a wrapper around a private key)
      account := solana.NewWallet()
      _ = account
    }
  }
}

{
  // Parse a public key from a base58 string:
  {
    publicKey, err := solana.PublicKeyFromBase58("F8UvVsKnzWyp2nF8aDcqvQ2GVcRpqT91WDsAtvBKCMt9")
    if err != nil {
      panic(err)
    }
    _ = publicKey
  }
  // OR:
  {
    publicKey := solana.MustPublicKeyFromBase58("F8UvVsKnzWyp2nF8aDcqvQ2GVcRpqT91WDsAtvBKCMt9")
    _ = publicKey
  }
}

Transfer Sol from one wallet to another wallet

package main

import (
  "context"
  "fmt"
  "os"
  "time"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/programs/system"
  "github.com/gagliardetto/solana-go/rpc"
  confirm "github.com/gagliardetto/solana-go/rpc/sendAndConfirmTransaction"
  "github.com/gagliardetto/solana-go/rpc/jsonrpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
  "github.com/gagliardetto/solana-go/text"
)

func main() {
  // Create a new RPC client:
  rpcClient := rpc.New(rpc.DevNet_RPC)

  // Create a new WS client (used for confirming transactions)
  wsClient, err := ws.Connect(context.Background(), rpc.DevNet_WS)
  if err != nil {
    panic(err)
  }

  // Load the account that you will send funds FROM:
  accountFrom, err := solana.PrivateKeyFromSolanaKeygenFile("/path/to/.config/solana/id.json")
  if err != nil {
    panic(err)
  }
  fmt.Println("accountFrom private key:", accountFrom)
  fmt.Println("accountFrom public key:", accountFrom.PublicKey())

  // The public key of the account that you will send sol TO:
  accountTo := solana.MustPublicKeyFromBase58("TODO")
  // The amount to send (in lamports);
  // 1 sol = 1000000000 lamports
  amount := uint64(3333)

  if true {
    // Airdrop 1 sol to the account so it will have something to transfer:
    out, err := rpcClient.RequestAirdrop(
      context.TODO(),
      accountFrom.PublicKey(),
      solana.LAMPORTS_PER_SOL*1,
      rpc.CommitmentFinalized,
    )
    if err != nil {
      panic(err)
    }
    fmt.Println("airdrop transaction signature:", out)
    time.Sleep(time.Second * 5)
  }
  //---------------

  recent, err := rpcClient.GetLatestBlockhash(context.TODO(), rpc.CommitmentFinalized)
  if err != nil {
    panic(err)
  }

  tx, err := solana.NewTransaction(
    []solana.Instruction{
      system.NewTransferInstruction(
        amount,
        accountFrom.PublicKey(),
        accountTo,
      ).Build(),
    },
    recent.Value.Blockhash,
    solana.TransactionPayer(accountFrom.PublicKey()),
  )
  if err != nil {
    panic(err)
  }

  _, err = tx.Sign(
    func(key solana.PublicKey) *solana.PrivateKey {
      if accountFrom.PublicKey().Equals(key) {
        return &accountFrom
      }
      return nil
    },
  )
  if err != nil {
    panic(fmt.Errorf("unable to sign transaction: %w", err))
  }
  spew.Dump(tx)
  // Pretty print the transaction:
  tx.EncodeTree(text.NewTreeEncoder(os.Stdout, "Transfer SOL"))

  // Send transaction, and wait for confirmation:
  sig, err := confirm.SendAndConfirmTransaction(
    context.TODO(),
    rpcClient,
    wsClient,
    tx,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(sig)

  // Or just send the transaction WITHOUT waiting for confirmation:
  // sig, err := rpcClient.SendTransactionWithOpts(
  //   context.TODO(),
  //   tx,
  //   false,
  //   rpc.CommitmentFinalized,
  // )
  // if err != nil {
  //   panic(err)
  // }
  // spew.Dump(sig)
}

RPC usage examples

RPC Methods

index > RPC > GetAccountInfo

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  bin "github.com/gagliardetto/binary"
  solana "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/programs/token"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  {
    pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
    // basic usage
    resp, err := client.GetAccountInfo(
      context.TODO(),
      pubKey,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(resp)

    var mint token.Mint
    // Account{}.Data.GetBinary() returns the *decoded* binary data
    // regardless the original encoding (it can handle them all).
    err = bin.NewDecoder(resp.GetBinary()).Decode(&mint)
    if err != nil {
      panic(err)
    }
    spew.Dump(mint)
    // NOTE: The supply is mint.Supply, with the mint.Decimals:
    // mint.Supply = 9998022451607088
    // mint.Decimals = 6
    // ... which means that the supply is 9998022451.607088
  }
  {
    // Or you can use `GetAccountDataInto` which does all of the above in one call:
    pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
    var mint token.Mint
    // Get the account, and decode its data into the provided mint object:
    err := client.GetAccountDataInto(
      context.TODO(),
      pubKey,
      &mint,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(mint)
  }
  {
    // // Or you can use `GetAccountDataBorshInto` which does all of the above in one call but for borsh-encoded data:
    // var metadata token_metadata.Metadata
    // // Get the account, and decode its data into the provided metadata object:
    // err := client.GetAccountDataBorshInto(
    //   context.TODO(),
    //   pubKey,
    //   &metadata,
    // )
    // if err != nil {
    //   panic(err)
    // }
    // spew.Dump(metadata)
  }
  {
    pubKey := solana.MustPublicKeyFromBase58("4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R") // raydium token
    // advanced usage
    resp, err := client.GetAccountInfoWithOpts(
      context.TODO(),
      pubKey,
      // You can specify more options here:
      &rpc.GetAccountInfoOpts{
        Encoding:   solana.EncodingBase64Zstd,
        Commitment: rpc.CommitmentFinalized,
        // You can get just a part of the account data by specify a DataSlice:
        // DataSlice: &rpc.DataSlice{
        //  Offset: pointer.ToUint64(0),
        //  Length: pointer.ToUint64(1024),
        // },
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(resp)

    var mint token.Mint
    err = bin.NewDecoder(resp.GetBinary()).Decode(&mint)
    if err != nil {
      panic(err)
    }
    spew.Dump(mint)
  }
}

index > RPC > GetBalance

package main

import (
  "context"
  "fmt"
  "math/big"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("7xLk17EQQ5KLDLDe44wCmupJKJjTGd8hs3eSVVhCx932")
  out, err := client.GetBalance(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
  spew.Dump(out.Value) // total lamports on the account; 1 sol = 1000000000 lamports

  var lamportsOnAccount = new(big.Float).SetUint64(uint64(out.Value))
  // Convert lamports to sol:
  var solBalance = new(big.Float).Quo(lamportsOnAccount, new(big.Float).SetUint64(solana.LAMPORTS_PER_SOL))

  // WARNING: this is not a precise conversion.
  fmt.Println("◎", solBalance.Text('f', 10))
}

index > RPC > GetBlock

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(context.TODO(), rpc.CommitmentFinalized)
  if err != nil {
    panic(err)
  }

  {
    out, err := client.GetBlock(context.TODO(), uint64(example.Context.Slot))
    if err != nil {
      panic(err)
    }
    // spew.Dump(out) // NOTE: This generates a lot of output.
    spew.Dump(len(out.Transactions))
  }

  {
    includeRewards := false
    out, err := client.GetBlockWithOpts(
      context.TODO(),
      uint64(example.Context.Slot),
      // You can specify more options here:
      &rpc.GetBlockOpts{
        Encoding:   solana.EncodingBase64,
        Commitment: rpc.CommitmentFinalized,
        // Get only signatures:
        TransactionDetails: rpc.TransactionDetailsSignatures,
        // Exclude rewards:
        Rewards: &includeRewards,
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetBlockCommitment

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(context.TODO(), rpc.CommitmentFinalized)
  if err != nil {
    panic(err)
  }

  out, err := client.GetBlockCommitment(
    context.TODO(),
    uint64(example.Context.Slot),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetBlockHeight

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetBlockHeight(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetBlockProduction

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  {
    out, err := client.GetBlockProduction(context.TODO())
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
  {
    out, err := client.GetBlockProductionWithOpts(
      context.TODO(),
      &rpc.GetBlockProductionOpts{
        Commitment: rpc.CommitmentFinalized,
        // Range: &rpc.SlotRangeRequest{
        //  FirstSlot: XXXXXX,
        //  Identity:  solana.MustPublicKeyFromBase58("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
        // },
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetBlockTime

package main

import (
  "context"
  "time"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  out, err := client.GetBlockTime(
    context.TODO(),
    uint64(example.Context.Slot),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
  spew.Dump(out.Time().Format(time.RFC1123))
}

index > RPC > GetBlocks

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  endSlot := uint64(example.Context.Slot)
  out, err := client.GetBlocks(
    context.TODO(),
    uint64(example.Context.Slot-3),
    &endSlot,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetBlocksWithLimit

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  limit := uint64(4)
  out, err := client.GetBlocksWithLimit(
    context.TODO(),
    uint64(example.Context.Slot-10),
    limit,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetClusterNodes

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetClusterNodes(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetConfirmedBlock

package main

import (
  "context"

  "github.com/AlekSi/pointer"
  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  { // deprecated and is going to be removed in solana-core v1.8
    out, err := client.GetConfirmedBlock(
      context.TODO(),
      uint64(example.Context.Slot),
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
  {
    slot := uint64(example.Context.Slot)
    out, err := client.GetConfirmedBlockWithOpts(
      context.TODO(),
      slot,
      // You can specify more options here:
      &rpc.GetConfirmedBlockOpts{
        Encoding:   solana.EncodingBase64,
        Commitment: rpc.CommitmentFinalized,
        // Get only signatures:
        TransactionDetails: rpc.TransactionDetailsSignatures,
        // Exclude rewards:
        Rewards: pointer.ToBool(false),
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetConfirmedBlocks

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  {
    endSlot := uint64(example.Context.Slot)
    // deprecated and is going to be removed in solana-core v1.8
    out, err := client.GetConfirmedBlocks(
      context.TODO(),
      uint64(example.Context.Slot-3),
      &endSlot,
      rpc.CommitmentFinalized,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetConfirmedBlocksWithLimit

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  limit := uint64(3)
  { // deprecated and is going to be removed in solana-core v1.8
    out, err := client.GetConfirmedBlocksWithLimit(
      context.TODO(),
      uint64(example.Context.Slot-10),
      limit,
      rpc.CommitmentFinalized,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetConfirmedSignaturesForAddress2

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
  {
    // deprecated and is going to be removed in solana-core v1.8
    out, err := client.GetConfirmedSignaturesForAddress2(
      context.TODO(),
      pubKey,
      // TODO:
      nil,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetConfirmedTransaction

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
  // Let's get a valid transaction to use in the example:
  example, err := client.GetConfirmedSignaturesForAddress2(
    context.TODO(),
    pubKey,
    nil,
  )
  if err != nil {
    panic(err)
  }

  out, err := client.GetConfirmedTransaction(
    context.TODO(),
    example[0].Signature,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetEpochInfo

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetEpochInfo(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetEpochSchedule

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetEpochSchedule(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetFeeCalculatorForBlockhash

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  out, err := client.GetFeeCalculatorForBlockhash(
    context.TODO(),
    example.Value.Blockhash,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetFeeRateGovernor

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetFeeRateGovernor(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetFees

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetFees(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetFeeForMessage

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetFeeForMessage(
    context.Background(),
    "AQABAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAA",
    rpc.CommitmentProcessed,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(example)
}

index > RPC > GetFirstAvailableBlock

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetFirstAvailableBlock(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetGenesisHash

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetGenesisHash(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetHealth

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetHealth(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
  spew.Dump(out == rpc.HealthOk)
}

index > RPC > GetHighestSnapshotSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetHighestSnapshotSlot(
    context.Background(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(example)
}

index > RPC > GetLatestBlockhash

NEW: This method is only available in solana-core v1.9 or newer. Please use getRecentBlockhash for solana-core v1.8

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.Background(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(example)
}

index > RPC > GetIdentity

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetIdentity(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetInflationGovernor

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetInflationGovernor(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetInflationRate

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetInflationRate(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetInflationReward

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("6dmNQ5jwLeLk5REvio1JcMshcbvkYMwy26sJ8pbkvStu")

  out, err := client.GetInflationReward(
    context.TODO(),
    []solana.PublicKey{
      pubKey,
    },
    &rpc.GetInflationRewardOpts{
      Commitment: rpc.CommitmentFinalized,
    },
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetLargestAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetLargestAccounts(
    context.TODO(),
    rpc.CommitmentFinalized,
    rpc.LargestAccountsFilterCirculating,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetLeaderSchedule

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetLeaderSchedule(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out) // NOTE: this creates a lot of output
}

index > RPC > GetMaxRetransmitSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetMaxRetransmitSlot(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetMaxShredInsertSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetMaxShredInsertSlot(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetMinimumBalanceForRentExemption

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  dataSize := uint64(1024 * 9)
  out, err := client.GetMinimumBalanceForRentExemption(
    context.TODO(),
    dataSize,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetMultipleAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  {
    out, err := client.GetMultipleAccounts(
      context.TODO(),
      solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt"),  // serum token
      solana.MustPublicKeyFromBase58("4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R"), // raydium token
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
  {
    out, err := client.GetMultipleAccountsWithOpts(
      context.TODO(),
      []solana.PublicKey{solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt"), // serum token
        solana.MustPublicKeyFromBase58("4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R"), // raydium token
      },
      &rpc.GetMultipleAccountsOpts{
        Encoding:   solana.EncodingBase64Zstd,
        Commitment: rpc.CommitmentFinalized,
        // You can get just a part of the account data by specify a DataSlice:
        // DataSlice: &rpc.DataSlice{
        //  Offset: pointer.ToUint64(0),
        //  Length: pointer.ToUint64(1024),
        // },
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetProgramAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetProgramAccounts(
    context.TODO(),
    solana.MustPublicKeyFromBase58("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(len(out))
  spew.Dump(out) // NOTE: this can generate a lot of output
}

index > RPC > GetRecentBlockhash

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  // DEPRECATED: This method is only available in solana-core v1.8 or older. Please use getLatestBlockhash for solana-core v1.9 or newer.
  recent, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(recent)
}

index > RPC > GetRecentPerformanceSamples

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  limit := uint(3)
  out, err := client.GetRecentPerformanceSamples(
    context.TODO(),
    &limit,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetRecentPrioritizationFees

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetRecentPrioritizationFees(
    context.TODO(),
    []solana.PublicKey{
      solana.MustPublicKeyFromBase58("q5BgreVhTyBH1QCeriVb7kQYEPneanFXPLjvyjdf8M3"),
    },
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSignatureStatuses

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSignatureStatuses(
    context.TODO(),
    true,
    // All the transactions you want the get the status for:
    solana.MustSignatureFromBase58("2CwH8SqVZWFa1EvsH7vJXGFors1NdCuWJ7Z85F8YqjCLQ2RuSHQyeGKkfo1Tj9HitSTeLoMWnxpjxF2WsCH8nGWh"),
    solana.MustSignatureFromBase58("5YJHZPeHZuZjhunBc1CCB1NDRNf2tTJNpdb3azGsR7PfyEncCDhr95wG8EWrvjNXBc4wCKixkheSbCxoC2NCG3X7"),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSignaturesForAddress

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSignaturesForAddress(
    context.TODO(),
    solana.MustPublicKeyFromBase58("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSlot(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSlotLeader

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSlotLeader(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSlotLeaders

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  recent, err := client.GetLatestBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  out, err := client.GetSlotLeaders(
    context.TODO(),
    uint64(recent.Context.Slot),
    10,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSnapshotSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSnapshotSlot(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetStakeActivation

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("EW2p7QCJNHMVj5nQCcW7Q2BDETtNBXn68FyucU4RCjvb")
  out, err := client.GetStakeActivation(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
    nil,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSupply

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSupply(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTokenAccountBalance

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("EzK5qLWhftu8Z2znVa5fozVtobbjhd8Gdu9hQHpC8bec")
  out, err := client.GetTokenAccountBalance(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTokenAccountsByDelegate

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("AfkALUPjQp8R1rUwE6KhT38NuTYWCncwwHwcJu7UtAfV")
  out, err := client.GetTokenAccountsByDelegate(
    context.TODO(),
    pubKey,
    &rpc.GetTokenAccountsConfig{
      Mint: solana.MustPublicKeyFromBase58("So11111111111111111111111111111111111111112"),
    },
    nil,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTokenAccountsByOwner

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  bin "github.com/gagliardetto/binary"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/programs/token"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("7HZaCWazgTuuFuajxaaxGYbGnyVKwxvsJKue1W4Nvyro")
  out, err := client.GetTokenAccountsByOwner(
    context.TODO(),
    pubKey,
    &rpc.GetTokenAccountsConfig{
      Mint: solana.WrappedSol.ToPointer(),
    },
    &rpc.GetTokenAccountsOpts{
      Encoding: solana.EncodingBase64Zstd,
    },
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)

  {
    tokenAccounts := make([]token.Account, 0)
    for _, rawAccount := range out.Value {
      var tokAcc token.Account

      data := rawAccount.Account.Data.GetBinary()
      dec := bin.NewBinDecoder(data)
      err := dec.Decode(&tokAcc)
      if err != nil {
        panic(err)
      }
      tokenAccounts = append(tokenAccounts, tokAcc)
    }
    spew.Dump(tokenAccounts)
  }
}

index > RPC > GetTokenLargestAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
  out, err := client.GetTokenLargestAccounts(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTokenSupply

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
  out, err := client.GetTokenSupply(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTransaction

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  txSig := solana.MustSignatureFromBase58("4bjVLV1g9SAfv7BSAdNnuSPRbSscADHFe4HegL6YVcuEBMY83edLEvtfjE4jfr6rwdLwKBQbaFiGgoLGtVicDzHq")
  {
    out, err := client.GetTransaction(
      context.TODO(),
      txSig,
      &rpc.GetTransactionOpts{
        Encoding: solana.EncodingBase64,
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
    spew.Dump(out.Transaction.GetBinary())

    decodedTx, err := solana.TransactionFromDecoder(bin.NewBinDecoder(out.Transaction.GetBinary()))
    if err != nil {
      panic(err)
    }
    spew.Dump(decodedTx)
  }
  {
    out, err := client.GetTransaction(
      context.TODO(),
      txSig,
      nil,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
    spew.Dump(out.Transaction.GetParsedTransaction())
  }
}

index > RPC > GetTransactionCount

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetTransactionCount(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetVersion

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetVersion(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetVoteAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetVoteAccounts(
    context.TODO(),
    &rpc.GetVoteAccountsOpts{
      VotePubkey: solana.MustPublicKeyFromBase58("vot33MHDqT6nSwubGzqtc6m16ChcUywxV7tNULF19Vu"),
    },
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > IsBlockhashValid

package main

import (
  "context"
  "fmt"
  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  blockHash := solana.MustHashFromBase58("J7rBdM6AecPDEZp8aPq5iPSNKVkU5Q76F3oAV4eW5wsW")
  out, err := client.IsBlockhashValid(
    context.TODO(),
    blockHash,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
  spew.Dump(out.Value) // true or false

  fmt.Println("is blockhash valid:", out.Value)
}

index > RPC > MinimumLedgerSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.MinimumLedgerSlot(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > RequestAirdrop

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  amount := solana.LAMPORTS_PER_SOL // 1 sol
  pubKey := solana.MustPublicKeyFromBase58("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
  out, err := client.RequestAirdrop(
    context.TODO(),
    pubKey,
    amount,
    "",
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > SendTransaction

package main

func main() {

}

index > RPC > SimulateTransaction

package main

func main() {

}

Websocket Subscriptions

index > WS Subscriptions > AccountSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
)

func main() {
  ctx := context.Background()	
  client, err := ws.Connect(context.Background(), rpc.MainNetBeta_WS)
  if err != nil {
    panic(err)
  }
  program := solana.MustPublicKeyFromBase58("9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin") // serum

  {
    sub, err := client.AccountSubscribe(
      program,
      "",
    )
    if err != nil {
      panic(err)
    }
    defer sub.Unsubscribe()

    for {
      got, err := sub.Recv(ctx)
      if err != nil {
        panic(err)
      }
      spew.Dump(got)
    }
  }
  if false {
    sub, err := client.AccountSubscribeWithOpts(
      program,
      "",
      // You can specify the data encoding of the returned accounts:
      solana.EncodingBase64,
    )
    if err != nil {
      panic(err)
    }
    defer sub.Unsubscribe()

    for {
      got, err := sub.Recv(ctx)
      if err != nil {
        panic(err)
      }
      spew.Dump(got)
    }
  }
}

index > WS Subscriptions > LogsSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
)

func main() {
  ctx := context.Background()	
  client, err := ws.Connect(context.Background(), rpc.MainNetBeta_WS)
  if err != nil {
    panic(err)
  }
  program := solana.MustPublicKeyFromBase58("9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin") // serum

  {
    // Subscribe to log events that mention the provided pubkey:
    sub, err := client.LogsSubscribeMentions(
      program,
      rpc.CommitmentRecent,
    )
    if err != nil {
      panic(err)
    }
    defer sub.Unsubscribe()

    for {
      got, err := sub.Recv(ctx)
      if err != nil {
        panic(err)
      }
      spew.Dump(got)
    }
  }
  if false {
    // Subscribe to all log events:
    sub, err := client.LogsSubscribe(
      ws.LogsSubscribeFilterAll,
      rpc.CommitmentRecent,
    )
    if err != nil {
      panic(err)
    }
    defer sub.Unsubscribe()

    for {
      got, err := sub.Recv(ctx)
      if err != nil {
        panic(err)
      }
      spew.Dump(got)
    }
  }
}

index > WS Subscriptions > ProgramSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
)

func main() {
  ctx := context.Background()	
  client, err := ws.Connect(context.Background(), rpc.MainNetBeta_WS)
  if err != nil {
    panic(err)
  }
  program := solana.MustPublicKeyFromBase58("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") // token

  sub, err := client.ProgramSubscribeWithOpts(
    program,
    rpc.CommitmentRecent,
    solana.EncodingBase64Zstd,
    nil,
  )
  if err != nil {
    panic(err)
  }
  defer sub.Unsubscribe()

  for {
    got, err := sub.Recv(ctx)
    if err != nil {
      panic(err)
    }
    spew.Dump(got)

    decodedBinary := got.Value.Account.Data.GetBinary()
    if decodedBinary != nil {
      // spew.Dump(decodedBinary)
    }

    // or if you requested solana.EncodingJSONParsed and it is supported:
    rawJSON := got.Value.Account.Data.GetRawJSON()
    if rawJSON != nil {
      // spew.Dump(rawJSON)
    }
  }
}

index > WS Subscriptions > RootSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
)

func main() {
  ctx := context.Background()
  client, err := ws.Connect(context.Background(), rpc.TestNet_WS)
  if err != nil {
    panic(err)
  }

  sub, err := client.RootSubscribe()
  if err != nil {
    panic(err)
  }

  for {
    got, err := sub.Recv(ctx)
    if err != nil {
      panic(err)
    }
    spew.Dump(got)
  }
}

index > WS Subscriptions > SignatureSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
)

func main() {
  ctx := context.Background()
  client, err := ws.Connect(context.Background(), rpc.TestNet_WS)
  if err != nil {
    panic(err)
  }

  txSig := solana.MustSignatureFromBase58("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")

  sub, err := client.SignatureSubscribe(
    txSig,
    "",
  )
  if err != nil {
    panic(err)
  }
  defer sub.Unsubscribe()

  for {
    got, err := sub.Recv(ctx)
    if err != nil {
      panic(err)
    }
    spew.Dump(got)
  }
}

index > WS Subscriptions > SlotSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
)

func main() {
  ctx := context.Background()
  client, err := ws.Connect(context.Background(), rpc.TestNet_WS)
  if err != nil {
    panic(err)
  }

  sub, err := client.SlotSubscribe()
  if err != nil {
    panic(err)
  }
  defer sub.Unsubscribe()

  for {
    got, err := sub.Recv(ctx)
    if err != nil {
      panic(err)
    }
    spew.Dump(got)
  }
}

index > WS Subscriptions > VoteSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
)

func main() {
  ctx := context.Background()
  client, err := ws.Connect(context.Background(), rpc.MainNetBeta_WS)
  if err != nil {
    panic(err)
  }

  // NOTE: this subscription must be enabled by the node you're connecting to.
  // This subscription is disabled by default.
  sub, err := client.VoteSubscribe()
  if err != nil {
    panic(err)
  }
  defer sub.Unsubscribe()

  for {
    got, err := sub.Recv(ctx)
    if err != nil {
      panic(err)
    }
    spew.Dump(got)
  }
}

Contributing

We encourage everyone to contribute, submit issues, PRs, discuss. Every kind of help is welcome.

License

Apache 2.0

Credits

  • Gopher logo was originally created by Takuya Ueda (https://twitter.com/tenntenn). Licensed under the Creative Commons 3.0 Attributions license.

GoLang Resources

are all listed below.

GitHub - goyek/goyek: Task automation Go library
resource
~/github.com
gommon/color at master · labstack/gommon
resource
~/github.com
GitHub - blevesearch/bleve: A modern text/numeric/geo-spatial/vector indexing library for go
resource
~/github.com
GitHub - schollz/progressbar: A really basic thread-safe progress bar for Golang applications
resource
~/github.com
GitHub - free/concurrent-writer: Highly concurrent drop-in replacement for bufio.Writer
resource
~/github.com
GitHub - mattn/go-colorable
resource
~/github.com
GitHub - StudioSol/set: A simple Set data structure implementation in Go (Golang) using LinkedHashMap.
resource
~/github.com
GitHub - essentialkaos/branca: Authenticated encrypted API tokens (IETF XChaCha20-Poly1305 AEAD) for Golang
resource
~/github.com
Cloud Native Computing Foundation
resource
~/www.cncf.io
GitHub - sakirsensoy/genv: Genv is a library for Go (golang) that makes it easy to read and use environment variables in your projects. It also allows environment variables to be loaded from the .env file.
resource
~/github.com
GitHub - heetch/confita: Load configuration in cascade from multiple backends into a struct
resource
~/github.com
GitHub - brianvoe/sjwt: Simple JWT Golang
resource
~/github.com
GitHub - subpop/go-ini: Go package that encodes and decodes INI-files
resource
~/github.com
GitHub - DylanMeeus/GoAudio: Go tools for audio processing & creation 🎶
resource
~/github.com
GitHub - daviddengcn/go-colortext: Change the color of console text.
resource
~/github.com
GitHub - andOTP/andOTP: [Unmaintained] Open source two-factor authentication for Android
resource
~/github.com
GitHub - alfiankan/crab-config-files-templating: Dynamic configuration file templating tool for kubernetes manifest or general configuration files
resource
~/github.com
GitHub - viney-shih/go-cache: A flexible multi-layer Go caching library to deal with in-memory and shared cache by adopting Cache-Aside pattern.
resource
~/github.com
GitHub - TreyBastian/colourize: An ANSI colour terminal package for Go
resource
~/github.com
GitHub - Evertras/bubble-table: A customizable, interactive table component for the Bubble Tea framework
resource
~/github.com
GitHub - deatil/go-array: A Go package that read or set data from map, slice or json
resource
~/github.com
GitHub - cometbft/cometbft: CometBFT (fork of Tendermint Core): A distributed, Byzantine fault-tolerant, deterministic state machine replication engine
resource
~/github.com
GitHub - icza/session: Go session management for web servers (including support for Google App Engine - GAE).
resource
~/github.com
GitHub - cristalhq/jwt: Safe, simple and fast JSON Web Tokens for Go
resource
~/github.com
GitHub - lrita/cmap: a thread-safe concurrent map for go
resource
~/github.com
GitHub - wzshiming/ctc: Console Text Colors - The non-invasive cross-platform terminal color library does not need to modify the Print method
resource
~/github.com
GitHub - goradd/maps: map library using Go generics that offers a standard interface, go routine synchronization, and sorting
resource
~/github.com
GitHub - alfiankan/teleterm: Telegram Bot Exec Terminal Command
resource
~/github.com
GitHub - JeremyLoy/config: 12 factor configuration as a typesafe struct in as little as two function calls
resource
~/github.com
GitHub - goraz/onion: Layer based configuration for golang
resource
~/github.com
GitHub - tuupola/branca-spec: Authenticated and encrypted API tokens using modern crypto
resource
~/github.com
GitHub - codingsince1985/couchcache: A RESTful caching micro-service in Go backed by Couchbase
resource
~/github.com
GitHub - sbstjn/hanu: Golang Framework for writing Slack bots
resource
~/github.com
GitHub - gordonklaus/portaudio: Go bindings for the PortAudio audio I/O library
resource
~/github.com
GitHub - xyproto/permissions2: Middleware for keeping track of users, login states and permissions
resource
~/github.com
GitHub - mingrammer/cfmt: :art: Contextual fmt inspired by bootstrap color classes
resource
~/github.com
GitHub - swithek/sessionup: Straightforward HTTP session management
resource
~/github.com
GitHub - markbates/goth: Package goth provides a simple, clean, and idiomatic way to write authentication packages for Go web applications.
resource
~/github.com
GitHub - ttacon/chalk: Intuitive package for prettifying terminal/console output. http://godoc.org/github.com/ttacon/chalk
resource
~/github.com
GitHub - alexedwards/scs: HTTP Session Management for Go
resource
~/github.com
GitHub - akyoto/cache: :handbag: Cache arbitrary data with an expiration time.
resource
~/github.com
GitHub - dh1tw/gosamplerate: Go Bindings for libsamplerate
resource
~/github.com
GitHub - tejzpr/ordered-concurrently: Ordered-concurrently a library for concurrent processing with ordered output in Go. Process work concurrently and returns output in a channel in the order of input. It is useful in concurrently processing items in a queue, and get output in the order provided by the queue.
resource
~/github.com
GitHub - jxskiss/mcli: A minimal but powerful cli library for Go
resource
~/github.com
GitHub - guptarohit/asciigraph: Go package to make lightweight ASCII line graph ╭┈╯ in command line apps with no other dependencies.
resource
~/github.com
GitHub - kyleterry/tenyks: The Tenyks IRC bot.
resource
~/github.com
GitHub - muesli/termenv: Advanced ANSI style & color support for your terminal applications
resource
~/github.com
GitHub - mengzhuo/cookiestxt: cookiestxt implement parser of cookies txt format
resource
~/github.com
GitHub - adam-hanna/sessions: A dead simple, highly performant, highly customizable sessions middleware for go http servers.
resource
~/github.com
GitHub - GuilhermeCaruso/anko: :crystal_ball: Simple application watcher
resource
~/github.com
GitHub - perdata/treap: golang persistent immutable treap sorted sets
resource
~/github.com
GitHub - zitadel/oidc: Easy to use OpenID Connect client and server library written for Go and certified by the OpenID Foundation
resource
~/github.com
GitHub - magefile/mage: a Make/rake-like dev tool using Go
resource
~/github.com
GitHub - i582/cfmt: Small library for simple and convenient formatted stylized output to the console.
resource
~/github.com
GitHub - mum4k/termdash: Terminal based dashboard.
resource
~/github.com
GitHub - alecthomas/kingpin: CONTRIBUTIONS ONLY: A Go (golang) command line and flag parser
resource
~/github.com
Bencher - Continuous Benchmarking
resource
~/bencher.dev
GitHub - RijulGulati/otpgen: Library to generate TOTP/HOTP codes
resource
~/github.com
GitHub - liyue201/gostl: Data structure and algorithm library for go, designed to provide functions similar to C++ STL
resource
~/github.com
GitHub - mitchellh/cli: A Go library for implementing command-line interfaces.
resource
~/github.com
GitHub - akamensky/argparse: Argparse for golang. Just because `flag` sucks
resource
~/github.com
GitHub - iwanbk/bcache: Eventually consistent distributed in-memory cache Go library
resource
~/github.com
GitHub - ewohltman/ephemeral-roles: A Discord bot for managing ephemeral roles based upon voice channel member presence.
resource
~/github.com
GitHub - mewkiz/flac: Package flac provides access to FLAC (Free Lossless Audio Codec) streams.
resource
~/github.com
GitHub - shaj13/go-guardian: Go-Guardian is a golang library that provides a simple, clean, and idiomatic way to create powerful modern API and web authentication.
resource
~/github.com
GitHub - tosone/minimp3: Decode mp3 base on https://github.com/lieff/minimp3
resource
~/github.com
GitHub - o1egl/paseto: Platform-Agnostic Security Tokens implementation in GO (Golang)
resource
~/github.com
GitHub - mikespook/gorbac: goRBAC provides a lightweight role-based access control (RBAC) implementation in Golang.
resource
~/github.com
GitHub - olebedev/go-tgbot: Golang telegram bot API wrapper, session-based router and middleware
resource
~/github.com
GitHub - abraithwaite/jeff: 🍍Jeff provides the simplest way to manage web sessions in Go.
resource
~/github.com
GitHub - abusomani/go-palette: Decorate your terminals using Palette 🎨
resource
~/github.com
GitHub - liujianping/job: JOB, make your short-term command as a long-term job. 将命令行规划成任务的工具
resource
~/github.com
GitHub - igrmk/treemap: Generic sorted map for Go with red-black tree under the hood
resource
~/github.com
GitHub - go-task/task: A task runner / simpler Make alternative written in Go
resource
~/github.com
GitHub - pascaldekloe/jwt: JSON Web Token library
resource
~/github.com
GitHub - golang/oauth2: Go OAuth2
resource
~/github.com
GitHub - onrik/micha: Client lib for Telegram bot api
resource
~/github.com
GitHub - cyucelen/marker: 🖍️ Marker is the easiest way to match and mark strings for colorful terminal outputs!
resource
~/github.com
GitHub - rainu/go-command-chain: A go library for easy configure and run command chains. Such like pipelining in unix shells.
resource
~/github.com
GitHub - LimeChain/gosemble: Go-based framework for building Polkadot/Substrate-compatible runtimes. 🧱
resource
~/github.com
GitHub - maxcnunes/gaper: Builds and restarts a Go project when it crashes or some watched file changes
resource
~/github.com
GitHub - leaanthony/clir: A Simple and Clear CLI library. Dependency free.
resource
~/github.com
GitHub - joho/godotenv: A Go port of Ruby's dotenv library (Loads environment variables from .env files)
resource
~/github.com
GitHub - MonaxGT/parsefields: Tools for parse JSON-like logs for collecting unique fields and events
resource
~/github.com
GitHub - cocoonspace/fsm: Finite State Machine package in Go
resource
~/github.com
GitHub - jroimartin/gocui: Minimalist Go package aimed at creating Console User Interfaces.
resource
~/github.com
GitHub - cloudquery/cloudquery: The open source high performance ELT framework powered by Apache Arrow
resource
~/github.com
GitHub - go-telegram/bot: Telegram Bot API Go framework
resource
~/github.com
GitHub - iancmcc/bingo: Fast, zero-allocation, lexicographic-order-preserving packing/unpacking of native Go types to bytes.
resource
~/github.com
GitHub - InVisionApp/tabular: Tabular simplifies printing ASCII tables from command line utilities
resource
~/github.com
GitHub - mattn/go-isatty
resource
~/github.com
GitHub - vbauerster/mpb: multi progress bar for Go cli applications
resource
~/github.com
GitHub - shomali11/slacker: Slack Bot Framework
resource
~/github.com
GitHub - tendermint/tendermint: ⟁ Tendermint Core (BFT Consensus) in Go
resource
~/github.com
GitHub - openshift/osin: Golang OAuth2 server library
resource
~/github.com
GitHub - dghubble/gologin: Go login handlers for authentication providers (OAuth1, OAuth2)
resource
~/github.com
GitHub - charmbracelet/bubbles: TUI components for Bubble Tea 🫧
resource
~/github.com
GitHub - jawher/mow.cli: A versatile library for building CLI applications in Go
resource
~/github.com
GitHub - workanator/go-ataman: Another Text Attribute Manupulator
resource
~/github.com
GitHub - joerdav/xc: Markdown defined task runner.
resource
~/github.com
GitHub - cristalhq/acmd: Simple, useful and opinionated CLI package in Go.
resource
~/github.com
GitHub - jltorresm/otpgo: Time-Based One-Time Password (TOTP) and HMAC-Based One-Time Password (HOTP) library for Go.
resource
~/github.com
GitHub - gosuri/uitable: A go library to improve readability in terminal apps using tabular data
resource
~/github.com
GitHub - cheynewallace/tabby: A tiny library for super simple Golang tables
resource
~/github.com
GitHub - ThomasObenaus/go-conf: Library for easy configuration of a golang service
resource
~/github.com
GitHub - sasbury/mini: A golang package for parsing ini-style configuration files
resource
~/github.com
GitHub - hyfather/pipeline: Pipelines using goroutines
resource
~/github.com
GitHub - saniales/golang-crypto-trading-bot: A golang implementation of a console-based trading bot for cryptocurrency exchanges
resource
~/github.com
GitHub - gempir/go-twitch-irc: go irc client for twitch.tv
resource
~/github.com
GitHub - kelseyhightower/envconfig: Golang library for managing configuration data from environment variables
resource
~/github.com
GitHub - Comcast/gaad: GAAD (Go Advanced Audio Decoder)
resource
~/github.com
GitHub - go-chat-bot/bot: IRC, Slack, Telegram and RocketChat bot written in go
resource
~/github.com
hiboot/pkg/app/cli at master · hidevopsio/hiboot
resource
~/github.com
GitHub - adam-hanna/jwt-auth: This package provides json web token (jwt) middleware for goLang http servers
resource
~/github.com
GitHub - derekparker/trie: Data structure and relevant algorithms for extremely fast prefix/fuzzy string searching.
resource
~/github.com
GitHub - gansidui/skiplist: skiplist for golang
resource
~/github.com
GitHub - gen2brain/malgo: Mini audio library
resource
~/github.com
GitHub - golang-jwt/jwt: Go implementation of JSON Web Tokens (JWT).
resource
~/github.com
GitHub - num30/config: Declarative configuration for Go
resource
~/github.com
GitHub - yanzay/tbot: Go library for Telegram Bot API
resource
~/github.com
GitHub - emvi/null: Nullable Go types that can be marshalled/unmarshalled to/from JSON.
resource
~/github.com
GitHub - ezeoleaf/larry: Larry 🐦 is a bot generator that post content from different providers to one or multiple publishers
resource
~/github.com
GitHub - Delta456/box-cli-maker: Make Highly Customized Boxes for CLI
resource
~/github.com
GitHub - vrischmann/envconfig: Small library to read your configuration from environment variables
resource
~/github.com
GitHub - tj/mmake: Modern Make
resource
~/github.com
GitHub - tmc/langchaingo: LangChain for Go, the easiest way to write LLM-based programs in Go
resource
~/github.com
GitHub - go-jose/go-jose: An implementation of JOSE standards (JWE, JWS, JWT) in Go
resource
~/github.com
GitHub - chmike/securecookie: Fast, secure and efficient secure cookie encoder/decoder
resource
~/github.com
GitHub - ethereum/go-ethereum: Go implementation of the Ethereum protocol
resource
~/github.com
GitHub - seiflotfy/cuckoofilter: Cuckoo Filter: Practically Better Than Bloom
resource
~/github.com
GitHub - openfga/openfga: A high performance and flexible authorization/permission engine built for developers and inspired by Google Zanzibar
resource
~/github.com
GitHub - opnlabs/dot: A minimal continuous integration system. Uses docker to run jobs concurrently in stages.
resource
~/github.com
GitHub - agext/levenshtein: Levenshtein distance and similarity metrics with customizable edit costs and Winkler-like bonus for common prefix.
resource
~/github.com
GitHub - nikepan/govkbot: VK bot package for Go
resource
~/github.com
GitHub - BoRuDar/configuration: Library for setting values to structs' fields from env, flags, files or default tag
resource
~/github.com
GitHub - c-bata/go-prompt: Building powerful interactive prompts in Go, inspired by python-prompt-toolkit.
resource
~/github.com
GitHub - taskctl/taskctl: Concurrent task runner, developer's routine tasks automation toolkit. Simple modern alternative to GNU Make 🧰
resource
~/github.com
GitHub - n10v/id3v2: 🎵 ID3 decoding and encoding library for Go
resource
~/github.com
GitHub - deckarep/golang-set: A simple, battle-tested and generic set type for the Go language. Trusted by Docker, 1Password, Ethereum and Hashicorp.
resource
~/github.com
GitHub - redpanda-data/connect: Fancy stream processing made operationally mundane
resource
~/github.com
GitHub - greencoda/confiq: Structured data format to config struct decoder library for Go
resource
~/github.com
GitHub - sgreben/flagvar: A collection of CLI argument types for the Go `flag` package.
resource
~/github.com
GitHub - ihebu/dsu: Disjoint Set data structure implementation in Go
resource
~/github.com
GitHub - zhulik/margelet: Telegram Bot Framework for Go
resource
~/github.com
GitHub - gurkankaymak/hocon: go implementation of lightbend's HOCON configuration library https://github.com/lightbend/config
resource
~/github.com
GitHub - tomlazar/table: pretty colorfull tables in go with less effort
resource
~/github.com
GitHub - antham/envh: Go helpers to manage environment variables
resource
~/github.com
GitHub - mudler/LocalAI: :robot: The free, Open Source alternative to OpenAI, Claude and others. Self-hosted and local-first. Drop-in replacement for OpenAI, running on consumer-grade hardware. No GPU required. Runs gguf, transformers, diffusers and many more models architectures. Features: Generate Text, Audio, Video, Images, Voice Cloning, Distributed inference
resource
~/github.com
GitHub - mattn/goveralls
resource
~/github.com
GitHub - Jagerente/gocfg: ⚙️ Golang config manager. Control your configurations using tags, unmarshal to structs, implement and inject your own value providers and parsers.
resource
~/github.com
GitHub - bytedance/sonic: A blazingly fast JSON serializing & deserializing library
resource
~/github.com
GitHub - caarlos0/env: A simple, zero-dependencies library to parse environment variables into structs
resource
~/github.com
GitHub - RijulGulati/go-andotp: CLI program to encrypt/decrypt andOTP files
resource
~/github.com
GitHub - carapace-sh/carapace: command argument completion generator for spf13/cobra
resource
~/github.com
GitHub - logrusorgru/aurora: Golang ultimate ANSI-colors that supports Printf/Sprintf methods
resource
~/github.com
GitHub - nazar256/parapipe: Paralleling pipeline
resource
~/github.com
GitHub - antham/strumt: Strumt is a library to create prompt chain
resource
~/github.com
GitHub - gosuri/uiprogress: A go library to render progress bars in terminal applications
resource
~/github.com
GitHub - kelindar/bitmap: Simple dense bitmap index in Go with binary operators
resource
~/github.com
GitHub - gammazero/deque: Fast ring-buffer deque (double-ended queue)
resource
~/github.com
GitHub - Yiling-J/piper: 🛠 Viper wrapper with config inheritance and key generation
resource
~/github.com
GitHub - erni27/imcache: A zero-dependency generic in-memory cache Go library
resource
~/github.com
GitHub - beatlabs/harvester: Harvest configuration, watch and notify subscriber
resource
~/github.com
GitHub - rocketlaunchr/remember-go: Cache Slow Database Queries
resource
~/github.com
GitHub - liujianping/ts: timestamp convert & compare tool. 时间戳转换与对比工具
resource
~/github.com
gone/jconf at master · One-com/gone
resource
~/github.com
GitHub - Yiling-J/theine-go: high performance in-memory cache
resource
~/github.com
GitHub - ThundR67/scope: Easily Manage OAuth2 Scopes In Go
resource
~/github.com
GitHub - briandowns/spinner: Go (golang) package with 90 configurable terminal spinner/progress indicators.
resource
~/github.com
GitHub - nikogura/gomason: A tool for testing, building, signing, and publishing binaries.
resource
~/github.com
Build software better, together
resource
~/github.com
GitHub - crgimenes/config: Configuration loader to use in Go projects
resource
~/github.com
GitHub - casbin/casbin: An authorization library that supports access control models like ACL, RBAC, ABAC in Golang: https://discord.gg/S5UjpzGZjN
resource
~/github.com
GitHub - jellydator/ttlcache: An in-memory cache with item expiration and generics
resource
~/github.com
GitHub - emirpasic/gods: GoDS (Go Data Structures) - Sets, Lists, Stacks, Maps, Trees, Queues, and much more
resource
~/github.com
GitHub - cosiner/argv
resource
~/github.com
GitHub - charmbracelet/bubbletea: A powerful little TUI framework 🏗
resource
~/github.com
GitHub - kkyr/fig: A minimalist Go configuration library
resource
~/github.com
GitHub - google/hilbert: Go package for mapping values to and from space-filling curves, such as Hilbert and Peano curves.
resource
~/github.com
GitHub - bobg/merkle: Merkle hash trees
resource
~/github.com
GitHub - emvi/hide: A Go type to prevent internal numeric IDs from being exposed to clients using HashIDs and JSON.
resource
~/github.com
GitHub - s0ders/go-semver-release: Go program designed to automate semantic versioning of Git repository by analyzing their formatted commit history and tagging them with the right semver.
resource
~/github.com
GitHub - zekroTJA/timedmap: A thread safe map which has expiring key-value pairs.
resource
~/github.com
GitHub - spf13/pflag: Drop-in replacement for Go's flag package, implementing POSIX/GNU-style --flags.
resource
~/github.com
GitHub - alexflint/go-arg: Struct-based argument parsing in Go
resource
~/github.com
GitHub - elastic/go-freelru: GC-less, fast and generic LRU hashmap library for Go
resource
~/github.com
GitHub - qvest-digital/loginsrv: JWT login microservice with plugable backends such as OAuth2, Google, Github, htpasswd, osiam, ..
resource
~/github.com
GitHub - ebitengine/oto: ♪ A low-level library to play sound on multiple platforms ♪
resource
~/github.com
GitHub - pterm/pterm: ✨ #PTerm is a modern Go module to easily beautify console output. Featuring charts, progressbars, tables, trees, text input, select menus and much more 🚀 It's completely configurable and 100% cross-platform compatible.
resource
~/github.com
GitHub - diegomarangoni/typenv: Go minimalist typed environment variables library
resource
~/github.com
GitHub - bits-and-blooms/bloom: Go package implementing Bloom filters, used by Milvus and Beego.
resource
~/github.com
GitHub - cheshir/ttlcache: Simple in-memory key-value storage with TTL for each record.
resource
~/github.com
GitHub - bobg/go-generics
resource
~/github.com
GitHub - no-src/nscache: A Go caching framework that supports multiple data source drivers
resource
~/github.com
GitHub - jaffee/commandeer: Automatically sets up command line flags based on struct fields and tags.
resource
~/github.com
GitHub - dixonwille/wmenu: An easy to use menu structure for cli applications that prompts users to make choices.
resource
~/github.com
GitHub - VictoriaMetrics/fastcache: Fast thread-safe inmemory cache for big number of entries in Go. Minimizes GC overhead
resource
~/github.com
GitHub - wkhere/bcl: Basic Configuration Language.
resource
~/github.com
GitHub - mszostok/version: 🧬 Pure DNA of your CLI!
resource
~/github.com
GitHub - Kwynto/gosession: This is quick session for net/http in golang. This package is perhaps the best implementation of the session mechanism, at least it tries to become one.
resource
~/github.com
GitHub - arl/go-rquad: :pushpin: State of the art point location and neighbour finding algorithms for region quadtrees, in Go
resource
~/github.com
GitHub - cosmos/cosmos-sdk: :chains: A Framework for Building High Value Public Blockchains :sparkles:
resource
~/github.com
GitHub - amallia/go-ef: A Go implementation of the Elias-Fano encoding
resource
~/github.com
GitHub - posener/complete: bash completion written in go + bash completion for go command
resource
~/github.com
GitHub - hedzr/cmdr: POSIX-compliant command-line UI (CLI) parser and Hierarchical-configuration operations
resource
~/github.com
GitHub - plar/go-adaptive-radix-tree: Adaptive Radix Trees implemented in Go
resource
~/github.com
GitHub - go-playground/overalls: :jeans:Multi-Package go project coverprofile for tools like goveralls
resource
~/github.com
GitHub - oracle/coherence-go-client: The Coherence Go Client allows native Go applications to act as cache clients to a Coherence cluster using gRPC for the network transport.
resource
~/github.com
GitHub - peterh/liner: Pure Go line editor with history, inspired by linenoise
resource
~/github.com
GitHub - ilyakaznacheev/cleanenv: ✨Clean and minimalistic environment configuration reader for Golang
resource
~/github.com
GitHub - omeid/uconfig: Lightweight, zero-dependency, and extendable configuration management library for Go
resource
~/github.com
GitHub - agnivade/levenshtein: Go implementation to calculate Levenshtein Distance.
resource
~/github.com
GitHub - dnote/dnote: A simple command line notebook for programmers
resource
~/github.com
GitHub - daichi-m/go18ds
resource
~/github.com
GitHub - ukautz/clif: Another CLI framework for Go. It works on my machine.
resource
~/github.com
GitHub - zentures/bloom: Bloom filters implemented in Go.
resource
~/github.com
GitHub - elves/elvish: Powerful scripting language & versatile interactive shell
resource
~/github.com
GitHub - wabarc/wayback: An archiving tool with an IM-style interface that prioritizes privacy and accessibility, integrated with various archival services including Internet Archive, archive.today, IPFS, Telegraph, and file systems.
resource
~/github.com
GitHub - oklahomer/go-sarah: Simple yet customizable bot framework written in Go.
resource
~/github.com
GitHub - alexandre-normand/slackscot: Slack bot core/framework written in Go with support for reactions to message updates/deletes
resource
~/github.com
GitHub - devfacet/gocmd: A Go library for building command line applications.
resource
~/github.com
GitHub - yaa110/goterator: Lazy iterator implementation for Golang
resource
~/github.com
GitHub - posener/cmd: The standard library flag package with its missing features
resource
~/github.com
GitHub - srfrog/slices: Functions that operate on slices. Similar to functions from package strings or package bytes that have been adapted to work with slices.
resource
~/github.com
GitHub - ianlopshire/go-ssm-config: Go utility for loading configuration parameters from AWS SSM (Parameter Store)
resource
~/github.com
GitHub - yitsushi/go-commander: Go library to simplify CLI workflow
resource
~/github.com
GitHub - OrlovEvgeny/go-mcache: Fast in-memory key:value store/cache with TTL
resource
~/github.com
GitHub - jf-tech/omniparser: omniparser: a native Golang ETL streaming parser and transform library for CSV, JSON, XML, EDI, text, etc.
resource
~/github.com
GitHub - enriquebris/goconcurrentqueue: Go concurrent-safe, goroutine-safe, thread-safe queue
resource
~/github.com
GitHub - zhuangsirui/binpacker: A binary stream packer and unpacker
resource
~/github.com
GitHub - jidicula/go-fuzz-action: GitHub Action for Go 1.18 fuzz testing
resource
~/github.com
GitHub - barweiss/go-tuple: Go 1.18+ generic tuple
resource
~/github.com
GitHub - RoaringBitmap/roaring: Roaring bitmaps in Go (golang), used by InfluxDB, Bleve, DataDog
resource
~/github.com
GitHub - lalamove/konfig: Composable, observable and performant config handling for Go for the distributed processing era
resource
~/github.com
GitHub - AlecAivazis/survey: A golang library for building interactive and accessible prompts with full support for windows and posix terminals.
resource
~/github.com
GitHub - go-gota/gota: Gota: DataFrames and data wrangling in Go (Golang)
resource
~/github.com
GitHub - gagliardetto/solana-go: Go SDK library and RPC client for the Solana Blockchain
resource
~/github.com
GitHub - nwillc/genfuncs: Go 1.18+ polymorphic generic containers and functions.
resource
~/github.com
GitHub - urfave/cli: A simple, fast, and fun package for building command line apps in Go
resource
~/github.com
GitHub - PaddleHQ/go-aws-ssm: Go package that interfaces with AWS System Manager
resource
~/github.com
GitHub - OpenPeeDeeP/xdg: A cross platform package that follows the XDG Standard
resource
~/github.com
GitHub - MauriceGit/skiplist: A Go library for an efficient implementation of a skip list: https://godoc.org/github.com/MauriceGit/skiplist
resource
~/github.com
GitHub - volatiletech/authboss: The boss of http auth.
resource
~/github.com
GitHub - spf13/cobra: A Commander for modern Go CLI interactions
resource
~/github.com
GitHub - OldPanda/bloomfilter: Yet another Bloomfilter implementation in Go, compatible with Java's Guava library
resource
~/github.com
GitHub - charmbracelet/lipgloss: Style definitions for nice terminal layouts 👄
resource
~/github.com
GitHub - vladopajic/go-test-coverage: go-test-coverage is tool and github action which reports issues when test coverage is below set threshold
resource
~/github.com
GitHub - carapace-sh/carapace-bin: multi-shell multi-command argument completer
resource
~/github.com
GitHub - ian-kent/gofigure: Go configuration made easy!
resource
~/github.com
GitHub - paked/configure: Configure is a Go package that gives you easy configuration of your project through redundancy
resource
~/github.com
GitHub - Zaba505/sand: Package for creating interpreters
resource
~/github.com
GitHub - jessevdk/go-flags: go command line option parser
resource
~/github.com
GitHub - dixonwille/wlog: A simple logging interface that supports cross-platform color and concurrency.
resource
~/github.com
GitHub - axiomhq/hyperloglog: HyperLogLog with lots of sugar (Sparse, LogLog-Beta bias correction and TailCut space reduction) brought to you by Axiom
resource
~/github.com
GitHub - embano1/memlog: A Kafka log inspired in-memory and append-only data structure
resource
~/github.com
GitHub - nasermirzaei89/env: Golang Get Environment Variables Package
resource
~/github.com
GitHub - ipfs/kubo: An IPFS implementation in Go
resource
~/github.com
GitHub - bluele/gcache: An in-memory cache library for golang. It supports multiple eviction policies: LRU, LFU, ARC
resource
~/github.com
GitHub - yosssi/gcss: Pure Go CSS Preprocessor
resource
~/github.com
GitHub - sherifabdlnaby/configuro: An opinionated configuration loading framework for Containerized and Cloud-Native applications.
resource
~/github.com
GitHub - innogames/slack-bot: Ready to use Slack bot for lazy developers: start Jenkins jobs, watch Jira tickets, watch pull requests with AI support...
resource
~/github.com
GitHub - romshark/yamagiconf: The magic YAML configuration framework for Go
resource
~/github.com
GitHub - shady831213/algorithms: CLRS study. Codes are written with golang.
resource
~/github.com
GitHub - harness/gitness: Gitness is an Open Source developer platform with Source Control management, Continuous Integration and Continuous Delivery.
resource
~/github.com
GitHub - BlackRabbitt/mspm: Multi-String Pattern Matching Algorithm Using TrieNode
resource
~/github.com
GitHub - tucnak/climax: Climax is an alternative CLI with the human face
resource
~/github.com
GitHub - nsf/termbox-go: Pure Go termbox implementation
resource
~/github.com
GitHub - reeflective/readline: Shell library with powerful and modern UI, large feature set, and `.inputrc` support
resource
~/github.com
GitHub - gha-common/go-beautiful-html-coverage: A GitHub Action to track code coverage in your pull requests, with a beautiful HTML preview, for free.
resource
~/github.com
GitHub - cristalhq/aconfig: Simple, useful and opinionated config loader.
resource
~/github.com
GitHub - hailocab/go-geoindex: Go native library for fast point tracking and K-Nearest queries
resource
~/github.com
GitHub - allegro/bigcache: Efficient cache for gigabytes of data written in Go.
resource
~/github.com
GitHub - viant/ptrie: A prefix tree implementation in go
resource
~/github.com
GitHub - floatdrop/2q
resource
~/github.com
GitHub - xxjwxc/gofal: fractional api base on golang . golang math tools fractional molecular denominator 分数计算 分子 分母 运算
resource
~/github.com
GitHub - creativecreature/sturdyc: A caching library with advanced concurrency features designed to make I/O heavy applications robust and highly performant
resource
~/github.com
GitHub - stellar-deprecated/kelp: Kelp is a free and open-source trading bot for the Stellar DEX and 100+ centralized exchanges
resource
~/github.com
GitHub - maypok86/otter: A high performance cache for Go
resource
~/github.com
GitHub - ulovecode/gdcache: gdcache is a pure non-intrusive cache library implemented by golang, you can use it to implement your own cache.
resource
~/github.com
GitHub - ory/keto: Open Source (Go) implementation of "Zanzibar: Google's Consistent, Global Authorization System". Ships gRPC, REST APIs, newSQL, and an easy and granular permission language. Supports ACL, RBAC, and other access models.
resource
~/github.com
GitHub - InVisionApp/conjungo: A small flexible merge library in go
resource
~/github.com
GitHub - go-telegram-bot-api/telegram-bot-api: Golang bindings for the Telegram Bot API
resource
~/github.com
GitHub - bits-and-blooms/bitset: Go package implementing bitsets
resource
~/github.com
GitHub - esimov/gogu: A comprehensive, reusable and efficient concurrent-safe generics utility functions and data structures library.
resource
~/github.com
GitHub - mdaliyan/icache: A High Performance, Generic, thread-safe, zero-dependency, key-value, in-memory cache
resource
~/github.com
GitHub - yourbasic/bit: Bitset data structure
resource
~/github.com
GitHub - integrii/flaggy: Idiomatic Go input parsing with subcommands, positional values, and flags at any position. No required project or package layout and no external dependencies.
resource
~/github.com
GitHub - muir/nfigure: Golang struct-tag based configfile and flag parsing
resource
~/github.com
GitHub - olivia-ai/olivia: 💁‍♀️Your new best friend powered by an artificial neural network
resource
~/github.com
GitHub - go-ini/ini: Package ini provides INI file read and write functionality in Go
resource
~/github.com
GitHub - air-verse/air: ☁️ Live reload for Go apps
resource
~/github.com
GitHub - adrg/xdg: Go implementation of the XDG Base Directory Specification and XDG user directories
resource
~/github.com
GitHub - mymmrac/telego: Telegram Bot API library for Go
resource
~/github.com
GitHub - oaStuff/clusteredBigCache: golang bigcache with clustering as a library.
resource
~/github.com
GitHub - cosiner/flag: Flag is a simple but powerful command line option parsing library for Go support infinite level subcommand
resource
~/github.com
GitHub - codingconcepts/env: Tag-based environment configuration for structs
resource
~/github.com
GitHub - gurukami/typ: Null Types, Safe primitive type conversion and fetching value from complex structures.
resource
~/github.com
GitHub - wlevene/ini: ini parser for golang
resource
~/github.com
GitHub - the4thamigo-uk/conflate: Library providing routines to merge and validate JSON, YAML and/or TOML files
resource
~/github.com
GitHub - DavidGamba/go-getoptions: Fully featured Go (golang) command line option parser with built-in auto-completion support.
resource
~/github.com
Build software better, together
resource
~/github.com
Build software better, together
resource
~/github.com
GitHub - tannerryan/ring: Package ring provides a high performance and thread safe Go implementation of a bloom filter.
resource
~/github.com
GitHub - gosuri/uilive: uilive is a go library for updating terminal output in realtime
resource
~/github.com
GitHub - gookit/color: 🎨 Terminal color rendering library, support 8/16 colors, 256 colors, RGB color rendering output, support Print/Sprintf methods, compatible with Windows. GO CLI 控制台颜色渲染工具库，支持16色，256色，RGB色彩渲染输出，使用类似于 Print/Sprintf，兼容并支持 Windows 环境的色彩渲染
resource
~/github.com
GitHub - yourbasic/bloom: Probabilistic set data structure
resource
~/github.com
GitHub - NicoNex/echotron: An elegant and concurrent library for the Telegram bot API in Go.
resource
~/github.com
GitHub - schachmat/ingo: persistent storage for flags in go
resource
~/github.com
GitHub - gizak/termui: Golang terminal dashboard
resource
~/github.com
GitHub - hjson/hjson-go: Hjson for Go
resource
~/github.com
GitHub - nil-go/konf: The simplest config loader for Go that reads/watches from file, env, flag and clouds (AWS, Azure, GCP).
resource
~/github.com
GitHub - bobg/subcmd
resource
~/github.com
GitHub - oblq/swap: Instantiate/configure structs recursively, based on build environment. (YAML, TOML, JSON and env).
resource
~/github.com
GitHub - linvon/cuckoo-filter: Cuckoo Filter go implement, better than Bloom Filter, configurable and space optimized 布谷鸟过滤器的Go实现，优于布隆过滤器，可以定制化过滤器参数，并进行了空间优化
resource
~/github.com
GitHub - twharmon/slices: Pure functions for slices.
resource
~/github.com
GitHub - woodpecker-ci/woodpecker: Woodpecker is a simple yet powerful CI/CD engine with great extensibility.
resource
~/github.com
GitHub - ufoscout/go-up: go-up! A simple configuration library with recursive placeholders resolution and no magic.
resource
~/github.com
GitHub - EchoVault/EchoVault: Embeddable and distributed in-memory alternative to Redis.
resource
~/github.com
GitHub - miladabc/gonfig: Tag based configuration loader from different providers
resource
~/github.com
GitHub - ollama/ollama: Get up and running with Llama 3.1, Mistral, Gemma 2, and other large language models.
resource
~/github.com
GitHub - golang/groupcache: groupcache is a caching and cache-filling library, intended as a replacement for memcached in many cases.
resource
~/github.com
GitHub - yuseferi/gocache: Gocache is an in-memory key:value store/cache (similar to Memcached) library for Go, suitable for single-machine applications. it is safe with concorent go routine access.
resource
~/github.com
GitHub - gopinath-langote/1build: Frictionless way of managing project-specific commands
resource
~/github.com
GitHub - tucnak/telebot: Telebot is a Telegram bot framework in Go.
resource
~/github.com
GitHub - teris-io/cli: Simple and complete API for building command line applications in Go
resource
~/github.com
GitHub - disksing/iter: Go implementation of C++ STL iterators and algorithms.
resource
~/github.com
GitHub - superwhiskers/crunch: take bytes out of things easily ✨🍪
resource
~/github.com
GitHub - wellington/go-libsass: Go wrapper for libsass, the only Sass 3.5 compiler for Go
resource
~/github.com
GitHub - octago/sflags: Generate flags by parsing structures
resource
~/github.com
GitHub - kak-tus/nan: Zero allocation Nullable structures in one library with handy conversion functions, marshallers and unmarshallers
resource
~/github.com
GitHub - mr-linch/go-tg: 🤖 Go client library for accessing Telegram Bot API, with batteries for building complex bots included.
resource
~/github.com
GitHub - gookit/config: 📝 Go configuration manage(load,get,set,export). support JSON, YAML, TOML, Properties, INI, HCL, ENV and Flags. Multi file load, data override merge, parse ENV var. Go应用配置加载管理，支持多种格式，多文件加载，远程文件加载，支持数据合并，解析环境变量名
resource
~/github.com
GitHub - eko/gocache: ☔️ A complete Go cache library that brings you multiple ways of managing your caches
resource
~/github.com
GitHub - tylertreat/BoomFilters: Probabilistic data structures for processing continuous, unbounded streams.
resource
~/github.com
GitHub - oxequa/realize: Realize is the #1 Golang Task Runner which enhance your workflow by automating the most common tasks and using the best performing Golang live reloading.
resource
~/github.com
GitHub - carapace-sh/carapace-spec: define simple completions using a spec file
resource
~/github.com
GitHub - dsbasko/go-cfg: The library provides a unified way to read configuration data from different sources, such as environment variables, command line flags, and configuration files.
resource
~/github.com
GitHub - mkideal/cli: CLI - A package for building command line app with go
resource
~/github.com
GitHub - edwingeng/deque: A highly optimized double-ended queue
resource
~/github.com
GitHub - kcmvp/gob: Golang project boot
resource
~/github.com
GitHub - muesli/cache2go: Concurrency-safe Go caching library with expiration capabilities and access counters
resource
~/github.com
GitHub - theckman/yacspin: Yet Another CLi Spinner; providing over 80 easy to use and customizable terminal spinners for multiple OSes
resource
~/github.com
GitHub - Workiva/go-datastructures: A collection of useful, performant, and threadsafe Go datastructures.
resource
~/github.com
GitHub - golobby/config: A lightweight yet powerful configuration manager for the Go programming language
resource
~/github.com
GitHub - alexeyco/simpletable: Simple tables in terminal with Go
resource
~/github.com
GitHub - syntaqx/env: An environment variable utility package
resource
~/github.com
GitHub - alecthomas/kong: Kong is a command-line parser for Go
resource
~/github.com
GitHub - GoTestTools/gotestfmt: go test output for humans
resource
~/github.com
GitHub - go-simpler/env: 🔍 Load environment variables into a config struct
resource
~/github.com
Stellar | Blockchain Network for Smart Contracts, DeFi, Payments & Asset Tokenization
resource
~/www.stellar.org
GitHub - joshbetz/config: 🛠 A configuration library for Go that parses environment variables, JSON files, and reloads automatically on SIGHUP.
resource
~/github.com
GitHub - ChainSafe/gossamer: 🕸️ Go Implementation of the Polkadot Host
resource
~/github.com
GitHub - s0rg/quadtree: Generic, zero-alloc, 100%-test covered Quadtree for golang
resource
~/github.com
GitHub - lawrencewoodman/roveralls: A Go recursive coverage testing tool
resource
~/github.com
GitHub - francesconi/go-rampart: Determine how intervals relate to each other.
resource
~/github.com
GitHub - zoumo/goset: Set is a useful collection but there is no built-in implementation in Go lang.
resource
~/github.com
GitHub - tucnak/store: A dead simple configuration manager for Go applications
resource
~/github.com
GitHub - seiflotfy/count-min-log: Go implementation of Count-Min-Log
resource
~/github.com
GitHub - srfrog/dict: Python-like dictionaries for Go
resource
~/github.com
GitHub - ovh/cds: Enterprise-Grade Continuous Delivery & DevOps Automation Open Source Platform
resource
~/github.com
GitHub - adrianbrad/queue: ⏪️ Go package providing multiple queue implementations. Developed in a thread-safe generic way.
resource
~/github.com
GitHub - nanovms/ops: ops - build and run nanos unikernels
resource
~/github.com
GitHub - faabiosr/cachego: Golang Cache component - Multiple drivers
resource
~/github.com
GitHub - hbollon/go-edlib: 📚 String comparison and edit distance algorithms library, featuring : Levenshtein, LCS, Hamming, Damerau levenshtein (OSA and Adjacent transpositions algorithms), Jaro-Winkler, Cosine, etc...
resource
~/github.com
GitHub - bobg/hashsplit
resource
~/github.com
GitHub - knadh/koanf: Simple, extremely lightweight, extensible, configuration management library for Go. Support for JSON, TOML, YAML, env, command line, file, S3 etc. Alternative to viper.
resource
~/github.com
GitHub - spf13/viper: Go configuration with fangs
resource
~/github.com
Build software better, together
resource
~/github.com
GitHub - nikepan/clickhouse-bulk: Collects many small inserts to ClickHouse and send in big inserts
resource
~/github.com
GitHub - olebedev/go-duktape: [abandoned] Duktape JavaScript engine bindings for Go
resource
~/github.com
GitHub - VictoriaMetrics/VictoriaMetrics: VictoriaMetrics: fast, cost-effective monitoring solution and time series database
resource
~/github.com
GoCQL
resource
~/gocql.github.io
GitHub - avito-tech/go-transaction-manager: Transaction manager for GoLang
resource
~/github.com
GitHub - rqlite/rqlite: The lightweight, user-friendly, distributed relational database built on SQLite.
resource
~/github.com
GitHub - georgysavva/scany: Library for scanning data from a database into Go structs and more
resource
~/github.com
QOS Energy / squalus · GitLab
resource
~/gitlab.com
GitHub - lawzava/go-pg-migrate: CLI-friendly package for pg migrations management.
resource
~/github.com
Parquet
resource
~/parquet.apache.org
pjrpc / pjrpc · GitLab
resource
~/gitlab.com
GitHub - go-gormigrate/gormigrate: Minimalistic database migration helper for Gorm ORM
resource
~/github.com
raylib
resource
~/www.raylib.com
GitHub - bartventer/gorm-multitenancy: 🚀📦 Multi-tenancy support for GORM managed databases
resource
~/github.com
goal
resource
~/codeberg.org
GitHub - rotisserie/eris: Error handling library with readable stack traces and flexible formatting support 🎆
resource
~/github.com
GitHub - philippgille/gokv: Simple key-value store abstraction and implementations for Go (Redis, Consul, etcd, bbolt, BadgerDB, LevelDB, Memcached, DynamoDB, S3, PostgreSQL, MongoDB, CockroachDB and many more)
resource
~/github.com
GitHub - nakagami/firebirdsql: Firebird RDBMS sql driver for Go (golang)
resource
~/github.com
GitHub - benmanns/goworker: goworker is a Go-based background worker that runs 10 to 100,000* times faster than Ruby-based workers.
resource
~/github.com
GitHub - name5566/leaf: A game server framework in Go (golang)
resource
~/github.com
GitHub - vanng822/go-premailer: Inline styling for html mail in golang
resource
~/github.com
GitHub - micro/go-micro: A Go microservices framework
resource
~/github.com
GitHub - zegl/goriak: goriak - Go language driver for Riak KV
resource
~/github.com
GitHub - go-jet/jet: Type safe SQL builder with code generation and automatic query result data mapping
resource
~/github.com
GitHub - timandy/routine: ThreadLocal for Golang.
resource
~/github.com
GitHub - zenthangplus/goccm: Limits the number of goroutines that are allowed to run concurrently
resource
~/github.com
GitHub - italolelis/outboxer: A library that implements the outboxer pattern in go
resource
~/github.com
GitHub - Shopify/go-lua: A Lua VM in Go
resource
~/github.com
alcastle / dyndns · GitLab
resource
~/gitlab.com
tozd / go / errors · GitLab
resource
~/gitlab.com
GitHub - jonchun/pathtype: Add a type for paths in Go.
resource
~/github.com
GitHub - cch123/elasticsql: convert sql to elasticsearch DSL in golang(go)
resource
~/github.com
GitHub - codingconcepts/dg: A fast data generator that produces CSV files from generated relational data
resource
~/github.com
GitHub - linkedin/goavro
resource
~/github.com
GitHub - ydb-platform/ydb-go-sdk: Pure Go native and database/sql driver for YDB
resource
~/github.com
GitHub - lopezator/migrator: Dead simple Go database migration library.
resource
~/github.com
GitHub - sosedoff/pgweb: Cross-platform client for PostgreSQL databases
resource
~/github.com
GitHub - xgzlucario/rotom: A tiny Redis server built with Golang, compatible with RESP protocols.
resource
~/github.com
GitHub - smallnest/rpcx: Best microservices framework in Go, like alibaba Dubbo, but with more features, Scale easily. Try it. Test it. If you feel it's better, use it! 𝐉𝐚𝐯𝐚有𝐝𝐮𝐛𝐛𝐨, 𝐆𝐨𝐥𝐚𝐧𝐠有𝐫𝐩𝐜𝐱! build for cloud!
resource
~/github.com
GitHub - hexdigest/execpool: A pool that spins up a given number of processes in advance and attaches stdin and stdout when needed. Very similar to FastCGI but works for any command.
resource
~/github.com
GitHub - cristalhq/builq: Easily build SQL queries in Go.
resource
~/github.com
GitHub - loveleshsharma/gohive: 🐝 A Highly Performant and easy to use goroutine pool for Go
resource
~/github.com
GitHub - dolthub/dolt: Dolt – Git for Data
resource
~/github.com
GitHub - svcavallar/celeriac.v1: Golang client library for adding support for interacting and monitoring Celery workers, tasks and events.
resource
~/github.com
GitHub - awalterschulze/goderive: Derives and generates mundane golang functions that you do not want to maintain yourself
resource
~/github.com
GitHub - ichiban/prolog: The only reasonable scripting engine for Go.
resource
~/github.com
GitHub - GuiaBolso/darwin: Database schema evolution library for Go
resource
~/github.com
GitHub - lindb/lindb: LinDB is a scalable, high performance, high availability distributed time series database.
resource
~/github.com
GitHub - cockroachdb/cockroach: CockroachDB — the cloud native, distributed SQL database designed for high availability, effortless scale, and control over data placement.
resource
~/github.com
GitHub - chrislusf/glow: Glow is an easy-to-use distributed computation system written in Go, similar to Hadoop Map Reduce, Spark, Flink, Storm, etc. I am also working on another similar pure Go system, https://github.com/chrislusf/gleam , which is more flexible and more performant.
resource
~/github.com
GitHub - mattn/go-oci8: Oracle driver for Go using database/sql
resource
~/github.com
GitHub - wzshiming/gotype: Golang source code parsing, usage like reflect package
resource
~/github.com
GitHub - HouzuoGuo/tiedot: A rudimentary implementation of a basic document (NoSQL) database in Go
resource
~/github.com
GitHub - deuill/go-php: PHP bindings for the Go programming language (Golang)
resource
~/github.com
GitHub - deatil/go-datebin: A date and time parse and format library for Go.
resource
~/github.com
GitHub - rafaelespinoza/godfish: a db migration manager
resource
~/github.com
GitHub - influxdata/influxdb: Scalable datastore for metrics, events, and real-time analytics
resource
~/github.com
GitHub - rocketlaunchr/dbq: Zero boilerplate database operations for Go
resource
~/github.com
GitHub - matm/go-nowpayments: Go library for the crypto NOWPayments API
resource
~/github.com
GitHub - golang-migrate/migrate: Database migrations. CLI and Golang library.
resource
~/github.com
GitHub - prashantgupta24/mac-sleep-notifier: macOS Sleep/ Wake notifications in golang
resource
~/github.com
GitHub - i25959341/orderbook: Matching Engine for Limit Order Book in Golang
resource
~/github.com
GitHub - larapulse/migrator: MySQL database migrator
resource
~/github.com
GitHub - robinjoseph08/go-pg-migrations: A Go package to help write migrations with go-pg/pg.
resource
~/github.com
GitHub - Masterminds/squirrel: Fluent SQL generation for golang
resource
~/github.com
GitHub - cockroachdb/pebble: RocksDB/LevelDB inspired key-value database in Go
resource
~/github.com
GitHub - otiai10/copy: Go copy directory recursively
resource
~/github.com
GitHub - ledisdb/ledisdb: A high performance NoSQL Database Server powered by Go
resource
~/github.com
GitHub - senselogic/GENERIS: Versatile Go code generator.
resource
~/github.com
GitHub - dastoori/higgs: A tiny cross-platform Go library to hide/unhide files and directories
resource
~/github.com
GitHub - goradd/html5tag: html5tag generates html 5 tags
resource
~/github.com
GitHub - unit-io/unitdb: Fast specialized time-series database for IoT, real-time internet connected devices and AI analytics.
resource
~/github.com
GitHub - rjeczalik/notify: File system event notification library on steroids.
resource
~/github.com
GitHub - cenkalti/rain: 🌧 BitTorrent client and library in Go
resource
~/github.com
GitHub - jamf/regatta: Regatta is a distributed key-value store. It is Kubernetes friendly with emphasis on high read throughput and low operational cost.
resource
~/github.com
GitHub - HDT3213/godis: A Golang implemented Redis Server and Cluster. Go 语言实现的 Redis 服务器和分布式集群
resource
~/github.com
GitHub - bradfitz/gomemcache: Go Memcached client library #golang
resource
~/github.com
GitHub - peterbourgon/diskv: A disk-backed key-value store.
resource
~/github.com
GitHub - jovandeginste/payme: QR code generator (ASCII & PNG) for SEPA payments
resource
~/github.com
GitHub - pressly/goose: A database migration tool. Supports SQL migrations and Go functions.
resource
~/github.com
GitHub - EngoEngine/engo: Engo is an open-source 2D game engine written in Go.
resource
~/github.com
GitHub - cloudwego/kitex: Go RPC framework with high-performance and strong-extensibility for building micro-services.
resource
~/github.com
GitHub - adlio/schema: Embedded schema migration package for Go
resource
~/github.com
GitHub - google/leveldb: LevelDB is a fast key-value storage library written at Google that provides an ordered mapping from string keys to string values.
resource
~/github.com
GitHub - syndtr/goleveldb: LevelDB key/value database in Go.
resource
~/github.com
GitHub - alpeb/go-finance: Go library containing a collection of financial functions for time value of money (annuities), cash flow, interest rate conversions, bonds and depreciation calculations.
resource
~/github.com
GitHub - go-sql-driver/mysql: Go MySQL Driver is a MySQL driver for Go's (golang) database/sql package
resource
~/github.com
GitHub - GuilhermeCaruso/kair: :clock1: Date and Time - Golang Formatting Library
resource
~/github.com
GitHub - akrylysov/pogreb: Embedded key-value store for read-heavy workloads written in Go
resource
~/github.com
GitHub - lni/dragonboat: A feature complete and high performance multi-group Raft library in Go.
resource
~/github.com
GitHub - andizzle/rwdb: Database wrapper that manage read write connections
resource
~/github.com
GitHub - gmsec/micro: A Go distributed systems development framework
resource
~/github.com
GitHub - 1set/cronrange: time range expression in cron style
resource
~/github.com
GitHub - fern4lvarez/piladb: Lightweight RESTful database engine based on stack data structures
resource
~/github.com
GitHub - dundee/gdu: Fast disk usage analyzer with console interface written in Go
resource
~/github.com
GitHub - emperror/errors: Drop-in replacement for the standard library errors package and github.com/pkg/errors
resource
~/github.com
GitHub - emersion/go-imap: 📥 An IMAP library for clients and servers
resource
~/github.com
GitHub - mattn/go-adodb: Microsoft ActiveX Object DataBase driver for go that using exp/sql
resource
~/github.com
GitHub - doug-martin/goqu: SQL builder and query library for golang
resource
~/github.com
GitHub - xiaoxin01/typeregistry: create type dynamically in Golang
resource
~/github.com
GitHub - jackc/pgx: PostgreSQL driver and toolkit for Go
resource
~/github.com
GitHub - lib/pq: Pure Go Postgres driver for database/sql
resource
~/github.com
GitHub - yaa110/go-persian-calendar: The implementation of Persian (Solar Hijri) Calendar in Go
resource
~/github.com
GitHub - ContentSquare/chproxy: Open-Source ClickHouse http proxy and load balancer
resource
~/github.com
GitHub - uber/ringpop-go: Scalable, fault-tolerant application-layer sharding for Go applications
resource
~/github.com
GitHub - rafaeljesus/tempdb: Key-value store for temporary items :memo:
resource
~/github.com
GitHub - wneessen/go-mail: 📧 Easy to use, yet comprehensive library for sending mails with Go
resource
~/github.com
GitHub - jcla1/gisp: Simple LISP in Go
resource
~/github.com
GitHub - prometheus/prometheus: The Prometheus monitoring system and time series database.
resource
~/github.com
GitHub - jexia/semaphore: Take control of your data, connect with anything, and expose it anywhere through protocols such as HTTP, GraphQL, and gRPC.
resource
~/github.com
GitHub - skeema/skeema: Declarative pure-SQL schema management for MySQL and MariaDB
resource
~/github.com
GitHub - andy2046/failured: Adaptive Accrual Failure Detector
resource
~/github.com
GitHub - jameycribbs/hare: Hare is a nimble little database management system for Go.
resource
~/github.com
GitHub - amacneil/dbmate: 🚀 A lightweight, framework-agnostic database migration tool.
resource
~/github.com
GitHub - liweiyi88/onedump: Effortlessly database dump with one command.
resource
~/github.com
GitHub - dgraph-io/badger: Fast key-value DB in Go.
resource
~/github.com
GitHub - rubenv/sql-migrate: SQL schema migration tool for Go.
resource
~/github.com
GitHub - rickb777/date: A Go package for working with dates
resource
~/github.com
GitHub - axllent/mailpit: An email and SMTP testing tool with API for developers
resource
~/github.com
GitHub - faiface/pixel: A hand-crafted 2D game library in Go
resource
~/github.com
GitHub - seiflotfy/skizze: A probabilistic data structure service and storage
resource
~/github.com
GitHub - x-mod/routine: go routine control, abstraction of the Main and some useful Executors.如果你不会管理Goroutine的话，用它
resource
~/github.com
GitHub - buraksezer/consistent: Consistent hashing with bounded loads in Golang
resource
~/github.com
GitHub - dixonwille/skywalker: A package to allow one to concurrently go through a filesystem with ease
resource
~/github.com
GitHub - xujiajun/godbal: Database Abstraction Layer (dbal) for Go. Support SQL builder and get result easily (now only support mysql)
resource
~/github.com
GitHub - cayleygraph/cayley: An open-source graph database
resource
~/github.com
GitHub - chrislusf/vasto: A distributed key-value store. On Disk. Able to grow or shrink without service interruption.
resource
~/github.com
GitHub - s0rg/fantasyname: RinkWorks fantasy name generator for golang
resource
~/github.com
GitHub - aerospike/aerospike-client-go: Aerospike Client Go
resource
~/github.com
GitHub - sj14/dbbench: 🏋️ dbbench is a simple database benchmarking tool which supports several databases and own scripts
resource
~/github.com
GitHub - govalues/decimal: Immutable floating-point decimals for Go
resource
~/github.com
GitHub - milvus-io/milvus: A cloud-native vector database, storage for next generation AI applications
resource
~/github.com
GitHub - go-the-way/sg: sg: A simple standard SQL generator written in Go.
resource
~/github.com
GitHub - prest/prest: PostgreSQL ➕ REST, low-code, simplify and accelerate development, ⚡ instant, realtime, high-performance on any Postgres application, existing or new
resource
~/github.com
GitHub - davemeehan/Neo4j-GO: Neo4j REST Client in golang
resource
~/github.com
GitHub - HnH/qry: Write your SQL queries in raw files with all benefits of modern IDEs, use them in an easy way inside your application with all the profit of compile time constants
resource
~/github.com
GitHub - awoodbeck/strftime: C99-compatible strftime formatter for use with Go time.Time instances.
resource
~/github.com
GitHub - osteele/tuesday: Ruby-compatible strftime for golang
resource
~/github.com
GitHub - gentee/gentee: Gentee - script programming language for automation. It uses VM and compiler written in Go (Golang).
resource
~/github.com
GitHub - ThundR67/falcon: A Simple Yet Highly Powerful Package For Error Handling
resource
~/github.com
GitHub - mattn/anko: Scriptable interpreter written in golang
resource
~/github.com
GitHub - chenmingyong0423/go-mongox: A Go Mongo library based on the official MongoDB driver, featuring streamlined document operations, generic binding of structs to collections, built-in CRUD, aggregation, automated field updates, struct validation, hooks, and plugin-based programming.
resource
~/github.com
GitHub - bsm/redislock: Simplified distributed locking implementation using Redis
resource
~/github.com
GitHub - recoilme/pudge: Fast and simple key/value store written using Go's standard library
resource
~/github.com
GitHub - z5labs/bedrock: A framework for building other frameworks
resource
~/github.com
GitHub - cihangir/neo4j: Neo4j Rest API Client for Go lang
resource
~/github.com
GitHub - hashicorp/raft: Golang implementation of the Raft consensus protocol
resource
~/github.com
GitHub - defcronyke/godscache: An unofficial Google Cloud Platform Go Datastore wrapper that adds caching using memcached. For App Engine Flexible, Compute Engine, Kubernetes Engine, and more.
resource
~/github.com
GitHub - jmhodges/levigo: levigo is a Go wrapper for LevelDB
resource
~/github.com
GitHub - jordan-wright/email: Robust and flexible email library for Go
resource
~/github.com
GitHub - PaesslerAG/gval: Expression evaluation in golang
resource
~/github.com
GitHub - lqs/sqlingo: 💥 A lightweight DSL & ORM which helps you to write SQL in Go.
resource
~/github.com
pop/soda at main · gobuffalo/pop
resource
~/github.com
GitHub - tobyhede/go-underscore: Helpfully Functional Go - A useful collection of Go utilities. Designed for programmer happiness.
resource
~/github.com
GitHub - temporalio/sdk-go: Temporal Go SDK
resource
~/github.com
GitHub - nutsdb/nutsdb: A simple, fast, embeddable, persistent key/value store written in pure Go. It supports fully serializable transactions and many data structures such as list, set, sorted set.
resource
~/github.com
GitHub - deckarep/gosx-notifier: gosx-notifier is a Go framework for sending desktop notifications to OSX 10.8 or higher
resource
~/github.com
GitHub - motrboat/hotcoal: Hotcoal - Secure your handcrafted SQL against injection
resource
~/github.com
GitHub - blastrain/octillery: Go package for sharding databases ( Supports every ORM or raw SQL )
resource
~/github.com
GitHub - elastic/go-elasticsearch: The official Go client for Elasticsearch
resource
~/github.com
GitHub - energye/energy: Energy is a framework developed by Go language based on CEF (Chromium Embedded Framework) for developing cross-platform desktop applications for Windows, Mac OS X, and Linux
resource
~/github.com
GitHub - elgris/sqrl: Fluent SQL generation for golang
resource
~/github.com
GitHub - uniplaces/carbon: Carbon for Golang, an extension for Time
resource
~/github.com
GitHub - amit-davidson/LibraDB: LibraDB is a simple, persistent key/value store written in pure Go in less than 1000 lines for learning purposes.
resource
~/github.com
GitHub - pupizoid/ormlite: Lightweight package containing some ORM-like features and helpers for sqlite databases.
resource
~/github.com
GitHub - hugocarreira/go-decent-copy: copy files for humans
resource
~/github.com
GitHub - skibish/ddns: Personal DDNS client with Digital Ocean Networking DNS as backend.
resource
~/github.com
GitHub - parsyl/parquet: A library for reading and writing parquet files.
resource
~/github.com
GitHub - emersion/go-message: ✉️ A streaming Go library for the Internet Message Format and mail messages
resource
~/github.com
GitHub - hprose/hprose-golang: Hprose is a cross-language RPC. This project is Hprose for Golang.
resource
~/github.com
GitHub - RichardKnop/go-fixtures: Django style fixtures for Golang's excellent built-in database/sql library.
resource
~/github.com
GitHub - PumpkinSeed/errors: Simple and efficient error package
resource
~/github.com
GitHub - cybertec-postgresql/pg_timetable: pg_timetable: Advanced scheduling for PostgreSQL
resource
~/github.com
GitHub - metacall/core: MetaCall: The ultimate polyglot programming experience.
resource
~/github.com
GitHub - twharmon/gosql: SQL query builder for Go
resource
~/github.com
GitHub - apache/calcite-avatica-go: Apache Calcite Go
resource
~/github.com
GitHub - go-kratos/kratos: Your ultimate Go microservices framework for the cloud-native era.
resource
~/github.com
GitHub - barasher/go-exiftool: Golang wrapper for Exiftool : extract as much metadata as possible (EXIF, ...) from files (pictures, pdf, office documents, ...)
resource
~/github.com
GitHub - achannarasappa/ticker: Terminal stock ticker with live updates and position tracking
resource
~/github.com
GitHub - artonge/go-csv-tag: Read csv file from go using tags
resource
~/github.com
GitHub - twharmon/dynago: Simplify working with AWS DynamoDB.
resource
~/github.com
GitHub - mholt/binding: Reflectionless data binding for Go's net/http (not actively maintained)
resource
~/github.com
GitHub - objectbox/objectbox-go: Embedded Go Database, the fast alternative to SQLite, gorm, etc.
resource
~/github.com
GitHub - aymerick/douceur: A simple CSS parser and inliner in Go
resource
~/github.com
GitHub - muir/libschema: database schema migrations on a per-library basis [Go]
resource
~/github.com
GitHub - db47h/ngaro: An embeddable implementation of the Ngaro Virtual Machine for Go programs
resource
~/github.com
GitHub - hexdigest/prep: Prep finds all SQL statements in a Go package and instruments db connection with prepared statements
resource
~/github.com
GitHub - sunary/sqlize: generate SQL migration schema from golang models and the current SQL schema.
resource
~/github.com
GitHub - mochi-mqtt/server: The fully compliant, embeddable high-performance Go MQTT v5 server for IoT, smarthome, and pubsub
resource
~/github.com
GitHub - viant/bgc: Datastore Connectivity for BigQuery in go
resource
~/github.com
GitHub - leporo/sqlf: Fast SQL query builder for Go
resource
~/github.com
GitHub - hypebeast/go-osc: Open Sound Control (OSC) library for Golang. Implemented in pure Go.
resource
~/github.com
GitHub - bytebase/bytebase: The GitHub/GitLab for database DevOps. World's most advanced database DevOps and CI/CD for Developer, DBA and Platform Engineering teams.
resource
~/github.com
GitHub - SaidinWoT/timespan: Golang package to manipulate time intervals.
resource
~/github.com
GitHub - shettyh/threadpool: Golang simple thread pool implementation
resource
~/github.com
GitHub - albrow/forms: A lightweight go library for parsing form data or json from an http.Request.
resource
~/github.com
GitHub - zhufuyi/sponge: Sponge is a powerful Go development framework, it's easy to develop web and microservice projects.
resource
~/github.com
GitHub - xo/xo: Command line tool to generate idiomatic Go code for SQL databases supporting PostgreSQL, MySQL, SQLite, Oracle, and Microsoft SQL Server
resource
~/github.com
GitHub - getlantern/systray: a cross platfrom Go library to place an icon and menu in the notification area
resource
~/github.com
GitHub - rafaeljesus/parallel-fn: Run functions in parallel :comet:
resource
~/github.com
GitHub - stoewer/go-week: A Go package to work with ISO 8601 week dates
resource
~/github.com
GitHub - ian-kent/purl: Perl, but fluffy like a cat!
resource
~/github.com
GitHub - ostafen/clover: A lightweight document-oriented NoSQL database written in pure Golang.
resource
~/github.com
GitHub - dgryski/go-jump: go-jump: Jump consistent hashing
resource
~/github.com
GitHub - go-kit/kit: A standard library for microservices.
resource
~/github.com
GitHub - couchbase/moss: moss - a simple, fast, ordered, persistable, key-val storage library for golang
resource
~/github.com
GitHub - mailhog/MailHog: Web and API based SMTP testing
resource
~/github.com
GitHub - liftbridge-io/liftbridge: Lightweight, fault-tolerant message streams.
resource
~/github.com
GitHub - ariga/atlas: Manage your database schema as code
resource
~/github.com
GitHub - bnkamalesh/currency: A currency computations package.
resource
~/github.com
GitHub - 1set/gut: 🍱 yet another collection of go utilities & tools
resource
~/github.com
GitHub - claygod/transaction: Embedded database for accounts transactions.
resource
~/github.com
GitHub - alexeyco/binder: High level go to Lua binder. Write less, do more.
resource
~/github.com
GitHub - ivpusic/grpool: Lightweight Goroutine pool
resource
~/github.com
GitHub - qustavo/sqlhooks: Attach hooks to any database/sql driver
resource
~/github.com
GitHub - pantrif/s2-geojson: Draw a polygon on the map or paste a geoJSON and explore how the s2.RegionCoverer covers it with S2 cells depending on the min and max levels
resource
~/github.com
GitHub - robfig/bind
resource
~/github.com
GitHub - sonh/qs: Go module for encoding structs into URL query parameters
resource
~/github.com
GitHub - mborders/artifex: Simple in-memory job queue for Golang using worker-based dispatching
resource
~/github.com
GitHub - AfterShip/email-verifier: :white_check_mark: A Go library for email verification without sending any emails.
resource
~/github.com
GitHub - aliexpressru/gomemcached: A Binary Memcached client for Go with support for sharding using consistent hashing, along with SASL.
resource
~/github.com
GitHub - bojanz/currency: Currency handling for Go.
resource
~/github.com
GitHub - mailhog/smtp: MailHog SMTP Protocol
resource
~/github.com
GitHub - dragonflyoss/Dragonfly2: Dragonfly is an open source P2P-based file distribution and image acceleration system. It is hosted by the Cloud Native Computing Foundation (CNCF) as an Incubating Level Project.
resource
~/github.com
Build software better, together
resource
~/github.com
GitHub - ddelizia/channelify: Make functions return a channel for parallel processing via go routines.
resource
~/github.com
GitHub - ggicci/httpin: 🍡 HTTP Input for Go - HTTP Request from/to Go Struct (Bi-directional Data Binding between Go Struct and http.Request)
resource
~/github.com
GitHub - hako/durafmt: :clock8: Better time duration formatting in Go!
resource
~/github.com
GitHub - ztrue/tracerr: Golang errors with stack trace and source fragments.
resource
~/github.com
GitHub - andygeiss/ecs: Build your own Game-Engine based on the Entity Component System concept in Golang.
resource
~/github.com
GitHub - HDT3213/rdb: Golang implemented Redis RDB parser for secondary development and memory analysis
resource
~/github.com
GitHub - pingcap/tidb: TiDB is an open-source, cloud-native, distributed, MySQL-Compatible database for elastic scale and real-time analytics. Try AI-powered Chat2Query free at : https://www.pingcap.com/tidb-serverless/
resource
~/github.com
GitHub - nullism/bqb: BQB is a lightweight and easy to use query builder that works with sqlite, mysql, mariadb, postgres, and others.
resource
~/github.com
GitHub - rosedblabs/rosedb: Lightweight, fast and reliable key/value storage engine based on Bitcask.
resource
~/github.com
GitHub - kirillDanshin/nulltime
resource
~/github.com
GitHub - stianeikeland/go-rpio: :electric_plug: Raspberry Pi GPIO library for go-lang
resource
~/github.com
GitHub - didi/gendry: a golang library for sql builder
resource
~/github.com
GitHub - valord577/mailx: A library that makes it easier to send email via SMTP.
resource
~/github.com
GitHub - justinas/nosurf: CSRF protection middleware for Go.
resource
~/github.com
GitHub - StudioSol/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.
resource
~/github.com
GitHub - globalsign/mgo: The MongoDB driver for Go
resource
~/github.com
GitHub - dannyvankooten/vat: Go package for dealing with EU VAT. Does VAT number validation & rates retrieval.
resource
~/github.com
GitHub - go-email-validator/go-email-validator: 📧 Golang Email address validator
resource
~/github.com
GitHub - wesql/wescale: WeScale is a Modern MySQL proxy that supports read-write-split, read-after-write-consistency, load balancing and OnlineDDL.
resource
~/github.com
GitHub - FeatureBaseDB/go-pilosa: Go client library for Pilosa
resource
~/github.com
GitHub - Jeffail/tunny: A goroutine pool for Go
resource
~/github.com
GitHub - kitstack/async-job: AsyncJob is an asynchronous queue job manager with light code, clear and speed. I hope so ! 😬
resource
~/github.com
GitHub - krotik/eliasdb: EliasDB a graph-based database.
resource
~/github.com
GitHub - aarzilli/golua: Go bindings for Lua C API - in progress
resource
~/github.com
GitHub - sanketplus/go-mysql-lock: MySQL Backed Locking Primitive
resource
~/github.com
GitHub - viant/dsc: Datastore Connectivity in go
resource
~/github.com
GitHub - ursiform/sleuth: A Go library for master-less peer-to-peer autodiscovery and RPC between HTTP services
resource
~/github.com
GitHub - nitishm/go-rejson: Golang client for redislabs' ReJSON module with support for multilple redis clients (redigo, go-redis)
resource
~/github.com
GitHub - trpc-group/trpc-go: A pluggable, high-performance RPC framework written in golang
resource
~/github.com
GitHub - google/starlark-go: Starlark in Go: the Starlark configuration language, implemented in Go
resource
~/github.com
GitHub - khezen/avro: Apache AVRO for go
resource
~/github.com
GitHub - bnkamalesh/errors: A drop-in replacement for Go errors, with some added sugar! Unwrap user-friendly messages, HTTP status code, easy wrapping with multiple error types.
resource
~/github.com
GitHub - subchen/go-trylock: TryLock support on read-write lock for Golang
resource
~/github.com
GitHub - arunsworld/nursery: Structured Concurrency in Go
resource
~/github.com
GitHub - ITcathyh/conexec: A concurrent toolkit to help execute funcs concurrently in an efficient and safe way. It supports specifying the overall timeout to avoid blocking.
resource
~/github.com
GitHub - jmattheis/goverter: Generate type-safe Go converters by simply defining an interface
resource
~/github.com
GitHub - sbinet/go-python: naive go bindings to the CPython2 C-API
resource
~/github.com
GitHub - pdupub/go-pdu: An PDU implementation in Go
resource
~/github.com
GitHub - reugn/async: Synchronization and asynchronous computation package for Go
resource
~/github.com
GitHub - Kamva/mgm: Mongo Go Models (mgm) is a fast and simple MongoDB ODM for Go (based on official Mongo Go Driver)
resource
~/github.com
GitHub - bokwoon95/go-structured-query: Type safe SQL query builder and struct mapper for Go
resource
~/github.com
GitHub - codingsince1985/checksum: Compute message digest for large files in Go
resource
~/github.com
GitHub - pieterclaerhout/go-finance: Finance related Go functions (e.g. exchange rates, VAT number checking, …)
resource
~/github.com
GitHub - solher/arangolite: Lightweight Golang driver for ArangoDB
resource
~/github.com
GitHub - wa-lang/wa: Wa is the best Wasm language
resource
~/github.com
Build software better, together
resource
~/github.com
GitHub - shurcooL/trayhost: Cross-platform Go library to place an icon in the host operating system's taskbar.
resource
~/github.com
GitHub - 1set/todotxt: Parser for todo.txt files in Go ✅
resource
~/github.com
GitHub - shopspring/decimal: Arbitrary-precision fixed-point decimal numbers in Go
resource
~/github.com
GitHub - zenthangplus/go-workerpool: Go WorkerPool aims to control heavy Go Routines
resource
~/github.com
GitHub - mmadfox/go-geojson2h3: Conversion utilities between H3 indexes and GeoJSON
resource
~/github.com
GitHub - nathan-osman/go-sunrise: Go package for calculating the sunrise and sunset times for a given location
resource
~/github.com
GitHub - OwnLocal/goes: A library to interact with Elasticsearch in Go!
resource
~/github.com
GitHub - xhit/go-simple-mail: Golang package for send email. Support keep alive connection, TLS and SSL. Easy for bulk SMTP.
resource
~/github.com
GitHub - BoltApp/sleet: Payment abstraction library - one interface for multiple payment processors ( inspired by Ruby's ActiveMerchant )
resource
~/github.com
GitHub - hectane/hectane: Lightweight SMTP client written in Go
resource
~/github.com
GitHub - nikhilsaraf/go-tools: A collection of tools for Golang
resource
~/github.com
GitHub - couchbase/goforestdb: Go bindings for ForestDB
resource
~/github.com
GitHub - d5/tengo: A fast script language for Go
resource
~/github.com
GitHub - rjeczalik/interfaces: Code generation tools for Go.
resource
~/github.com
GitHub - leebenson/conform: Trims, sanitizes & scrubs data based on struct tags (go, golang)
resource
~/github.com
GitHub - AppsFlyer/go-sundheit: A library built to provide support for defining service health for golang services. It allows you to register async health checks for your dependencies and the service itself, provides a health endpoint that exposes their status, and health metrics.
resource
~/github.com
GitHub - fogfish/dynamo: Generic Golang Key/Value trait for AWS storage services
resource
~/github.com
GitHub - snwfdhmp/errlog: Reduce debugging time. Use static & stack-trace analysis to identify the error immediately.
resource
~/github.com
GitHub - ahmetb/go-linq: .NET LINQ capabilities in Go
resource
~/github.com
GitHub - cogentcore/core: A free and open source framework for building powerful, fast, elegant 2D and 3D apps that run on macOS, Windows, Linux, iOS, Android, and the web with a single Go codebase, allowing you to Code Once, Run Everywhere.
resource
~/github.com
GitHub - sherifabdlnaby/gpool: gpool - a generic context-aware resizable goroutines pool to bound concurrency based on semaphore.
resource
~/github.com
GitHub - anacrolix/dht: dht is used by anacrolix/torrent, and is intended for use as a library in other projects both torrent related and otherwise
resource
~/github.com
GitHub - AaronJan/Hunch: Hunch provides functions like: All, First, Retry, Waterfall etc., that makes asynchronous flow control more intuitive.
resource
~/github.com
GitHub - 1set/starlet: ✨ Yet another Go wrapper for Starlark that simplifies usage, offers data conversion and useful Starlark libraries
resource
~/github.com
GitHub - surrealdb/surrealdb.go: SurrealDB SDK for Golang
resource
~/github.com
GitHub - nar10z/go-accumulator: Solution for accumulation of events and their subsequent processing.
resource
~/github.com
GitHub - hishamkaram/gismanager: Publish Your GIS Data(Vector Data) to PostGIS and Geoserver
resource
~/github.com
GitHub - bigfile/bigfile: Bigfile -- a file transfer system that supports http, rpc and ftp protocol https://bigfile.site
resource
~/github.com
GitHub - tidwall/buntdb: BuntDB is an embeddable, in-memory key/value database for Go with custom indexing and geospatial support
resource
~/github.com
GitHub - neuronlabs/errors: Simple golang error handling with classification primitives.
resource
~/github.com
GitHub - kamilsk/semaphore: 🚦 Semaphore pattern implementation with timeout of lock/unlock operations.
resource
~/github.com
GitHub - denisenkom/go-mssqldb: Microsoft SQL server driver written in go language
resource
~/github.com
GitHub - sendgrid/sendgrid-go: The Official Twilio SendGrid Golang API Library
resource
~/github.com
GitHub - alexeyco/pig: Simple pgx wrapper to execute and scan query results
resource
~/github.com
GitHub - expr-lang/expr: Expression language and expression evaluation for Go
resource
~/github.com
GitHub - dirkaholic/kyoo: Unlimited job queue for go, using a pool of concurrent workers processing the job queue entries
resource
~/github.com
GitHub - gotk3/gotk3: Go bindings for GTK3
resource
~/github.com
GitHub - nikolaydubina/fpmoney: 🧧 Fixed-Point Decimal Money
resource
~/github.com
GitHub - edwingeng/doublejump: A revamped Google's jump consistent hash
resource
~/github.com
GitHub - gonutz/prototype: Simple 2D game prototyping framework.
resource
~/github.com
GitHub - viant/asc: Datastore Connectivity for Aerospike for go
resource
~/github.com
GitHub - toorop/go-dkim: DKIM package for golang
resource
~/github.com
GitHub - Southclaws/fault: Go errors but structured and composable. Fault provides an extensible yet ergonomic mechanism for wrapping errors.
resource
~/github.com
GitHub - xis/baraka: a tool for handling file uploads simple
resource
~/github.com
GitHub - topfreegames/pitaya: Scalable game server framework with clustering support and client libraries for iOS, Android, Unity and others through the C SDK.
resource
~/github.com
GitHub - jinzhu/now: Now is a time toolkit for golang
resource
~/github.com
GitHub - artonge/go-gtfs: Load GTFS files in golang
resource
~/github.com
GitHub - prashantgupta24/activity-tracker: A library to notify about any (pluggable) activity on your machine, and let you take action as needed
resource
~/github.com
GitHub - mmadfox/go-h3geo-dist: H3-geo distributed cells
resource
~/github.com
GitHub - go-playground/form: :steam_locomotive: Decodes url.Values into Go value(s) and Encodes Go value(s) into url.Values. Dual Array and Full map support.
resource
~/github.com
GitHub - mattbaird/elastigo: A Go (golang) based Elasticsearch client library.
resource
~/github.com
GitHub - pdfcpu/pdfcpu: A PDF processor written in Go.
resource
~/github.com
GitHub - gen2brain/raylib-go: Go bindings for raylib, a simple and easy-to-use library to enjoy videogames programming.
resource
~/github.com
GitHub - marusama/semaphore: Fast resizable golang semaphore primitive
resource
~/github.com
GitHub - vladopajic/go-actor: A tiny library for writing concurrent programs in Go using actor model
resource
~/github.com
GitHub - krotik/ecal: A simple embeddable scripting language which supports concurrent event processing.
resource
~/github.com
GitHub - ungerik/go3d: A performance oriented 2D/3D math package for Go
resource
~/github.com
GitHub - maguro/pbf: OpenStreetMap PBF golang parser
resource
~/github.com
GitHub - emperror/emperror: The Emperor takes care of all errors personally
resource
~/github.com
GitHub - neilotoole/errgroup: errgroup with goroutine worker limits
resource
~/github.com
GitHub - hexdigest/gowrap: GoWrap is a command line tool for generating decorators for Go interfaces
resource
~/github.com
GitHub - zeromicro/go-zero: A cloud-native Go microservices framework with cli tool for productivity.
resource
~/github.com
GitHub - marusama/cyclicbarrier: CyclicBarrier golang implementation
resource
~/github.com
GitHub - arthurkushman/buildsqlx: Go database query builder library for PostgreSQL
resource
~/github.com
GitHub - monoculum/formam: a package for decode form's values into struct in Go
resource
~/github.com
GitHub - Rhymond/go-money: Go implementation of Fowler's Money pattern
resource
~/github.com
GitHub - valyala/gorpc: Simple, fast and scalable golang rpc library for high load
resource
~/github.com
GitHub - TomWright/queryparam: Go package to easily convert a URL's query parameters/values into usable struct values of the correct types.
resource
~/github.com
GitHub - sciter-sdk/go-sciter: Golang bindings of Sciter: the Embeddable HTML/CSS/script engine for modern UI development
resource
~/github.com
GitHub - yaitoo/async: Async is an asynchronous task package for Go
resource
~/github.com
Build software better, together
resource
~/github.com
GitHub - wroge/wgs84: A zero-dependency Go package for coordinate transformations.
resource
~/github.com
GitHub - azul3d/engine: Azul3D - A 3D game engine written in Go!
resource
~/github.com
GitHub - hmdsefi/gowl: Gowl is a process management and process monitoring tool at once. An infinite worker pool gives you the ability to control the pool and processes and monitor their status.
resource
~/github.com
GitHub - ssgreg/stl: Software Transactional Locks
resource
~/github.com
GitHub - vivek-ng/concurrency-limiter
resource
~/github.com
GitHub - tylfin/dynatomic: Dynatomic is a library for using dynamodb as an atomic counter
resource
~/github.com
GitHub - m1/go-finnhub: Simple and easy to use client for stock market, forex and crypto data from finnhub.io written in Go. Access real-time financial market data from 60+ stock exchanges, 10 forex brokers, and 15+ crypto exchanges
resource
~/github.com
GitHub - lonng/nano: Lightweight, facility, high performance golang based game server framework
resource
~/github.com
GitHub - google/cel-go: Fast, portable, non-Turing complete expression evaluation with gradual typing (Go)
resource
~/github.com
GitHub - osamingo/jsonrpc: The jsonrpc package helps implement of JSON-RPC 2.0
resource
~/github.com
GitHub - golang/geo: S2 geometry library in Go
resource
~/github.com
GitHub - roblillack/spot: React-like desktop GUI toolkit for Go
resource
~/github.com
GitHub - goplus/c2go: Convert C to Go
resource
~/github.com
GitHub - dgruber/drmaa: Compute cluster (HPC) job submission library for Go (#golang) based on the open DRMAA standard.
resource
~/github.com
GitHub - gammazero/workerpool: Concurrency limiting goroutine pool
resource
~/github.com
GitHub - xiaonanln/goworld: Scalable Distributed Game Server Engine with Hot Swapping in Golang
resource
~/github.com
GitHub - btnguyen2k/gocosmos: Go database/sql driver for Azure Cosmos DB SQL API
resource
~/github.com
GitHub - jorelosorio/web-mercator-projection: A Go project to explore the math to calculate and present data in a map using the `Web Mercator Projection`
resource
~/github.com
GitHub - gopherlibs/appindicator: :traffic_light: Go bindings for libappindicator3 C library
resource
~/github.com
GitHub - rethinkdb/rethinkdb-go: Go language driver for RethinkDB
resource
~/github.com
GitHub - kdomanski/iso9660: A go library for reading and creating ISO9660 images
resource
~/github.com
GitHub - JoelOtter/termloop: Terminal-based game engine for Go, built on top of Termbox
resource
~/github.com
GitHub - go-mysql-org/go-mysql: a powerful mysql toolset with Go
resource
~/github.com
GitHub - emitter-io/emitter: High performance, distributed and low latency publish-subscribe platform.
resource
~/github.com
GitHub - qmuntal/opc: Go implementation of the Open Packaging Conventions (OPC)
resource
~/github.com
GitHub - codenotary/immudb: immudb - immutable database based on zero trust, SQL/Key-Value/Document model, tamperproof, data change history
resource
~/github.com
GitHub - CovenantSQL/CovenantSQL: A decentralized, trusted, high performance, SQL database with blockchain features
resource
~/github.com
GitHub - mbrostami/consistenthash: A Go library that implements Consistent Hashing (+Block Partitioning)
resource
~/github.com
GitHub - peterstace/simplefeatures: Simple Features is a pure Go Implementation of the OpenGIS Simple Feature Access Specification
resource
~/github.com
GitHub - dgraph-io/dgraph: The high-performance database for modern applications
resource
~/github.com
GitHub - homedepot/flop: Go file operations library chasing GNU APIs.
resource
~/github.com
GitHub - tarmac-project/tarmac: Write as Functions, Deploy as a Monolith or Microservice with WebAssembly
resource
~/github.com
GitHub - minus5/gofreetds: Go Sql Server database driver.
resource
~/github.com
GitHub - dimuska139/go-email-normalizer: Golang library for providing a canonical representation of email address.
resource
~/github.com
GitHub - spatial-go/geoos: A library provides spatial data and geometric algorithms
resource
~/github.com
GitHub - ijt/go-anytime: Parse natural and standardized dates/times and ranges in Go without knowing the format in advance
resource
~/github.com
GitHub - beefsack/go-astar: Go implementation of the A* search algorithm
resource
~/github.com
GitHub - xtaci/gonet: A Game Server Skeleton in golang.
resource
~/github.com
GitHub - bdjimmy/gbind: Bind data to any Go value. Can use built-in and custom expression binding capabilities; supports data validation logic for Go values. // 将数据绑定到任何 Go 值。可使用内置和自定义表达式绑定能力；支持对Go值的数据校验逻辑.
resource
~/github.com
GitHub - vardius/worker-pool: Go simple async worker pool
resource
~/github.com
GitHub - hashicorp/go-multierror: A Go (golang) package for representing a list of errors as a single error.
resource
~/github.com
GitHub - jmcvetta/neoism: Neo4j client for Golang
resource
~/github.com
GitHub - harfang3d/harfang3d: HARFANG 3D source code public repository
resource
~/github.com
GitHub - matcornic/hermes: Golang package that generates clean, responsive HTML e-mails for sending transactional mail
resource
~/github.com
GitHub - goschtalt/approx: Package approx adds support for durations of days, weeks and years.
resource
~/github.com
GitHub - samber/mo: 🦄 Monads and popular FP abstractions, powered by Go 1.18+ Generics (Option, Result, Either...)
resource
~/github.com
GitHub - dtylman/gowd: Build cross platform GUI apps with GO and HTML/JS/CSS (powered by nwjs)
resource
~/github.com
GitHub - kelindar/column: High-performance, columnar, in-memory store with bitmap indexing in Go
resource
~/github.com
GitHub - webview/webview: Tiny cross-platform webview library for C/C++. Uses WebKit (GTK/Cocoa) and Edge WebView2 (Windows).
resource
~/github.com
GitHub - seborama/fuego: Functional Experiment in Golang
resource
~/github.com
GitHub - catmullet/go-workers: 👷 Library for safely running groups of workers concurrently or consecutively that require input and output through channels
resource
~/github.com
GitHub - claygod/coffer: Simply ACID* key-value database. At the medium or even low latency it tries to provide greater throughput without losing the ACID properties of the database. The database provides the ability to create record headers at own discretion and use them as transactions. The maximum size of stored data is limited by the size of the computer's RAM.
resource
~/github.com
GitHub - piaohao/godis: redis client implement by golang, inspired by jedis.
resource
~/github.com
GitHub - bsm/redeo: High-performance framework for building redis-protocol compatible TCP servers/services
resource
~/github.com
GitHub - vardius/gollback: Go asynchronous simple function utilities, for managing execution of closures and callbacks
resource
~/github.com
GitHub - lxn/walk: A Windows GUI toolkit for the Go Programming Language
resource
~/github.com
GitHub - nikolaydubina/fpdecimal: 🛫 Fixed-Point Decimals
resource
~/github.com
GitHub - therecipe/qt: Qt binding for Go (Golang) with support for Windows / macOS / Linux / FreeBSD / Android / iOS / Sailfish OS / Raspberry Pi / AsteroidOS / Ubuntu Touch / JavaScript / WebAssembly
resource
~/github.com
GitHub - tardisgo/tardisgo: Golang->Haxe->CPP/CSharp/Java/JavaScript transpiler
resource
~/github.com
GitHub - gorilla/csrf: Package gorilla/csrf provides Cross Site Request Forgery (CSRF) prevention middleware for Go web applications & services 🔒
resource
~/github.com
GitHub - s0rg/grid: Generic 2D grid
resource
~/github.com
GitHub - qustavo/dotsql: A Golang library for using SQL.
resource
~/github.com
GitHub - tidwall/tile38: Real-time Geospatial and Geofencing
resource
~/github.com
GitHub - maxence-charriere/go-app: A package to build progressive web apps with Go programming language and WebAssembly.
resource
~/github.com
GitHub - alitto/pond: 🔘 Minimalistic and High-performance goroutine worker pool written in Go
resource
~/github.com
GitHub - kamilsk/breaker: 🚧 Flexible mechanism to make execution flow interruptible.
resource
~/github.com
GitHub - vitessio/vitess: Vitess is a database clustering system for horizontal scaling of MySQL.
resource
~/github.com
GitHub - airbusgeo/godal: golang wrapper for github.com/OSGEO/gdal
resource
~/github.com
GitHub - andlabs/ui: Platform-native GUI library for Go.
resource
~/github.com
GitHub - repeale/fp-go: fp-go is a collection of Functional Programming helpers powered by Golang 1.18+ generics.
resource
~/github.com
GitHub - wlbr/feiertage: Gesetzliche Feiertage und mehr in Deutschland und Österreich (Bank holidays/public holidays in Austria and Germany)
resource
~/github.com
GitHub - gopherjs/gopherjs: A compiler from Go to JavaScript for running Go code in a browser
resource
~/github.com
GitHub - xhit/go-str2duration: Convert string to duration in golang
resource
~/github.com
GitHub - zcalusic/sysinfo: Sysinfo is a Go library providing Linux OS / kernel / hardware system information.
resource
~/github.com
GitHub - joomcode/errorx: A comprehensive error handling library for Go
resource
~/github.com
GitHub - aclindsa/ofxgo: Golang library for querying and parsing OFX
resource
~/github.com
GitHub - sqlc-dev/sqlc: Generate type-safe code from SQL
resource
~/github.com
GitHub - etcd-io/raft: Raft library for maintaining a replicated state machine
resource
~/github.com
GitHub - TeaEntityLab/fpGo: Monad, Functional Programming features for Golang
resource
~/github.com
GitHub - micro/micro: An API first development platform
resource
~/github.com
GitHub - destel/rill: Go concurrency with channel transformations: a toolkit for streaming, batching, pipelines, and error handling
resource
~/github.com
GitHub - rjNemo/underscore: 🌟 Useful functional programming helpers for Go
resource
~/github.com
GitHub - cvilsmeier/sqinn-go: Golang SQLite without cgo
resource
~/github.com
GitHub - redis/go-redis: Redis Go client
resource
~/github.com
GitHub - foxcpp/maddy: ✉️ Composable all-in-one mail server.
resource
~/github.com
GitHub - oakmound/oak: A pure Go game engine
resource
~/github.com
GitHub - Konstantin8105/c4go: Transpiling C code to Go code
resource
~/github.com
GitHub - sdcoffey/techan: Technical Analysis Library for Golang
resource
~/github.com
GitHub - kamildrazkiewicz/go-flow: Simply way to control goroutines execution order based on dependencies
resource
~/github.com
GitHub - leekchan/timeutil: timeutil - useful extensions (Timedelta, Strftime, ...) to the golang's time package
resource
~/github.com
GitHub - etcd-io/bbolt: An embedded key/value database for Go.
resource
~/github.com
GitHub - mongodb/mongo-go-driver: The Official Golang driver for MongoDB
resource
~/github.com
GitHub - nats-io/nats-server: High-Performance server for NATS.io, the cloud and edge native messaging system.
resource
~/github.com
GitHub - securitybunker/databunker: Secure Vault for Customer PII/PHI/PCI/KYC Records
resource
~/github.com
GitHub - veandco/go-sdl2: SDL2 binding for Go
resource
~/github.com
GitHub - go-playground/pool: :speedboat: a limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation
resource
~/github.com
GitHub - truemail-rb/truemail-go: 🚀 Configurable Golang 📨 email validator/verifier. Verify email via Regex, DNS, SMTP and even more. Be sure that email address valid and exists.
resource
~/github.com
GitHub - grpc/grpc-go: The Go language implementation of gRPC. HTTP/2 based RPC
resource
~/github.com
GitHub - earthboundkid/flowmatic: Structured concurrency made easy
resource
~/github.com
GitHub - paulmach/osm: General purpose library for reading, writing and working with OpenStreetMap data
resource
~/github.com
GitHub - rbrahul/gofp: A super simple Lodash like utility library with essential functions that empowers the development in Go
resource
~/github.com
GitHub - abice/go-enum: An enum generator for go
resource
~/github.com
GitHub - couchbase/go-couchbase: Couchbase client in Go
resource
~/github.com
GitHub - C2FO/vfs: Pluggable, extensible virtual file system for Go
resource
~/github.com
GitHub - phelmkamp/valor: Go option and result types that optionally contain a value
resource
~/github.com
GitHub - switchupcb/copygen: Go generator to copy values from type to type and fields from struct to struct (copier without reflection). Generate any code based on types.
resource
~/github.com
GitHub - rbrahul/exception: A simple utility package for exception handling with try-catch in Golang
resource
~/github.com
GitHub - uber/h3-go: Go bindings for H3, a hierarchical hexagonal geospatial indexing system
resource
~/github.com
GitHub - leekchan/accounting: money and currency formatting for golang
resource
~/github.com
GitHub - sourcegraph/conc: Better structured concurrency for go
resource
~/github.com
GitHub - consbio/mbtileserver: Basic Go server for mbtiles
resource
~/github.com
GitHub - shomali11/xredis: Go Redis Client
resource
~/github.com
GitHub - capillariesio/capillaries: Distributed batch data processing framework
resource
~/github.com
GitHub - anacrolix/torrent: Full-featured BitTorrent client package and utilities
resource
~/github.com
GitHub - godror/godror: GO DRiver for ORacle DB
resource
~/github.com
GitHub - hajimehoshi/ebiten: Ebitengine - A dead simple 2D game engine for Go
resource
~/github.com
GitHub - fyne-io/fyne: Cross platform GUI toolkit in Go inspired by Material Design
resource
~/github.com
GitHub - pieterclaerhout/go-waitgroup: A sync.WaitGroup with error handling and concurrency control
resource
~/github.com
GitHub - workanator/go-floc: Floc: Orchestrate goroutines with ease.
resource
~/github.com
GitHub - mailgun/mailgun-go: Go library for sending mail with the Mailgun API.
resource
~/github.com
GitHub - hishamkaram/geoserver: geoserver is a Go library for manipulating a GeoServer instance via the GeoServer REST API.
resource
~/github.com
GitHub - xxjwxc/gowp: golang worker pool , Concurrency limiting goroutine pool
resource
~/github.com
GitHub - araddon/dateparse: GoLang Parse many date strings without knowing format in advance.
resource
~/github.com
GitHub - 0xcafed00d/joystick: Go Joystick API
resource
~/github.com
GitHub - gomodule/redigo: Go client for Redis
resource
~/github.com
GitHub - go-ozzo/ozzo-dbx: A Go (golang) package that enhances the standard database/sql package by providing powerful data retrieval methods as well as DB-agnostic query building capabilities.
resource
~/github.com
GitHub - relvacode/iso8601: A fast ISO8601 date parser for Go
resource
~/github.com
GitHub - ClickHouse/clickhouse-go: Golang driver for ClickHouse
resource
~/github.com
GitHub - luraproject/lura: Ultra performant API Gateway with middlewares. A project hosted at The Linux Foundation
resource
~/github.com
GitHub - bykof/gostradamus: Gostradamus: Better DateTimes for Go 🕰️
resource
~/github.com
GitHub - cinar/checker: Checker is a Go library for validating user input through checker rules provided in struct tags.
resource
~/github.com
GitHub - vectaport/flowgraph: Flowgraph package for scalable asynchronous system development
resource
~/github.com
GitHub - ktr0731/evans: Evans: more expressive universal gRPC client
resource
~/github.com
periph
resource
~/periph.io
gomponents, HTML components in pure Go
resource
~/www.gomponents.com
GitHub - Jeffail/gabs: For parsing, creating and editing unknown or dynamic JSON in Go
resource
~/github.com
GitHub - agonopol/go-stem: Word Stemming in Go
resource
~/github.com
GitHub - marekm4/color-extractor: Simple image color extractor written in Go with no external dependencies
resource
~/github.com
GreyXor / Slogor · GitLab
resource
~/gitlab.com
ipaddress — IPv4/IPv6 manipulation library
resource
~/docs.python.org
GitHub - xybor-x/xylog: Python-like logging design in Golang
resource
~/github.com
GitHub - FiloSottile/age: A simple, modern and secure encryption tool (and Go library) with small explicit keys, no config options, and UNIX-style composability.
resource
~/github.com
GitHub - mozillazg/go-unidecode: ASCII transliterations of Unicode text.
resource
~/github.com
Log Analysis | Log Management by Loggly
resource
~/www.loggly.com
GitHub - Terry-Mao/gopush-cluster: Golang push server cluster
resource
~/github.com
Buckley / di · GitLab
resource
~/gitlab.com
Consul by HashiCorp
resource
~/www.consul.io
GitHub - aybabtme/portproxy: TCP proxy, highjacks HTTP to allow CORS
resource
~/github.com
GitHub - eapache/go-resiliency: Resiliency patterns for golang
resource
~/github.com
GitHub - DimitarPetrov/stegify: 🔍 Go tool for LSB steganography, capable of hiding any file within an image.
resource
~/github.com
GitHub - otiai10/ocrserver: A simple OCR API server, seriously easy to be deployed by Docker, on Heroku as well
resource
~/github.com
GitHub - viant/endly: End to end functional test and automation framework
resource
~/github.com
GitHub - shirou/gopsutil: psutil for golang
resource
~/github.com
GitHub - gansidui/gotcp: A Go package for quickly building tcp servers
resource
~/github.com
GitHub - mustafaturan/bus: 🔊Minimalist message bus implementation for internal communication with zero-allocation magic on Emit
resource
~/github.com
GitHub - schuyler/neural-go: A multilayer perceptron network implemented in Go, with training via backpropagation.
resource
~/github.com
GitHub - bolknote/go-gd: Go bingings for GD (http://www.boutell.com/gd/)
resource
~/github.com
GitHub - chmike/varint: variable length integer encoding using prefix code
resource
~/github.com
GitHub - sinhashubham95/jsonic: All you need with JSON
resource
~/github.com
GitHub - akrennmair/gopcap: A simple wrapper around libpcap for the Go programming language
resource
~/github.com
GitHub - corona10/goimghdr: The imghdr module determines the type of image contained in a file for go
resource
~/github.com
GitHub - muesli/smartcrop: smartcrop finds good image crops for arbitrary crop sizes
resource
~/github.com
GitHub - yazgazan/jaydiff: A JSON diff utility
resource
~/github.com
GitHub - seanhagen/bradleyterry: Package to do Bradley-Terry Model pairwise compairsons
resource
~/github.com
GitHub - golang/dep: Go dependency management tool experiment (deprecated)
resource
~/github.com
GitHub - gographics/imagick: Go binding to ImageMagick's MagickWand C API
resource
~/github.com
GitHub - bamiaux/rez: Image resizing in pure Go and SIMD
resource
~/github.com
GitHub - ian-kent/go-log: A logger, for Go
resource
~/github.com
GitHub - noelyahan/mergi: go library for image programming (merge, crop, resize, watermark, animate, ease, transit)
resource
~/github.com
GitHub - apex/log: Structured logging package for Go.
resource
~/github.com
GitHub - sagikazarmark/modern-go-application: Modern Go Application example
resource
~/github.com
GitHub - qmuntal/gltf: Go library for encoding glTF 2.0 files
resource
~/github.com
GitHub - jbrodriguez/mlog: A simple logging module for go, with a rotating file feature and console logging.
resource
~/github.com
GitHub - donatj/mpo: JPEG-MPO Decoder / Converter Library and CLI Tool
resource
~/github.com
GitHub - kilgaloon/leprechaun: You had one job, or more then one, which can be done in steps
resource
~/github.com
GitHub - jyotiska/go-webcolors: Port of webcolors library from Python to Go
resource
~/github.com
GitHub - aerogo/log: :memo: Logging with multiple output targets.
resource
~/github.com
GitHub - e-dard/godist: Probability distributions and associated methods in Go
resource
~/github.com
Tymoteusz Blazejczyk / Go Formatter · GitLab
resource
~/gitlab.com
Build software better, together
resource
~/github.com
GitHub - goiot/devices: Suite of libraries for IoT devices (written in Go), experimental for x/exp/io
resource
~/github.com
GitHub - romshark/sched: A job scheduler for Go with the ability to fast-forward time.
resource
~/github.com
kit/log at master · go-kit/kit
resource
~/github.com
GitHub - kolesa-team/go-webp: Simple and fast webp library for golang
resource
~/github.com
GitHub - centrifugal/centrifugo: Scalable real-time messaging server in a language-agnostic way. Self-hosted alternative to Pubnub, Pusher, Ably. Set up once and forever.
resource
~/github.com
GitHub - onatm/clockwerk: Job Scheduling Library
resource
~/github.com
GitHub - spyzhov/ajson: Abstract JSON for Golang with JSONPath support
resource
~/github.com
GitHub - auyer/steganography: Pure Golang Library that allows LSB steganography on images using ZERO dependencies
resource
~/github.com
GitHub - datastream/libsvm: libsvm go version
resource
~/github.com
GitHub - inconshreveable/log15: Structured, composable logging for Go
resource
~/github.com
GitHub - corona10/goimagehash: Go Perceptual image hashing package
resource
~/github.com
GitHub - qeesung/image2ascii: :foggy: Convert image to ASCII
resource
~/github.com
GitHub - dannyvankooten/extemplate: Wrapper package for Go's template/html to allow for easy file-based template inheritance.
resource
~/github.com
gone/log at master · One-com/gone
resource
~/github.com
GitHub - bamzi/jobrunner: Framework for performing work asynchronously, outside of the request flow
resource
~/github.com
GitHub - mehanizm/iuliia-go: Transliterate Cyrillic → Latin in every possible way
resource
~/github.com
GitHub - nikolaydubina/go-featureprocessing: 🔥 Fast, simple sklearn-like feature processing for Go
resource
~/github.com
GitHub - eaigner/shield: Bayesian text classifier with flexible tokenizers and storage backends for Go
resource
~/github.com
GitHub - tdewolff/canvas: Cairo in Go: vector to raster, SVG, PDF, EPS, WASM, OpenGL, Gio, etc.
resource
~/github.com
GitHub - mehdipourfar/webp-server: Simple and minimal image server capable of storing, resizing, converting and caching images.
resource
~/github.com
GitHub - Wing924/shellwords: A Golang library to manipulate strings according to the word parsing rules of the UNIX Bourne shell.
resource
~/github.com
GitHub - kak-tus/ami: Go client to reliable queues based on Redis Cluster Streams
resource
~/github.com
GitHub - GeertJohan/go.rice: go.rice is a Go package that makes working with resources such as html,js,css,images,templates, etc very easy.
resource
~/github.com
GitHub - h2non/baloo: Expressive end-to-end HTTP API testing made easy in Go
resource
~/github.com
GitHub - uber-go/fx: A dependency injection based application framework for Go.
resource
~/github.com
GitHub - nao1215/gup: gup - Update binaries installed by "go install" with goroutines.
resource
~/github.com
GitHub - heartwilltell/log: Simple leveled logging wrapper around standard log package
resource
~/github.com
GitHub - go-gl/mathgl: A pure Go 3D math library.
resource
~/github.com
GitHub - shixzie/nlp: [UNMANTEINED] Extract values from strings and fill your structs with nlp.
resource
~/github.com
GitHub - m-zajac/json2go: Create go type representation from json
resource
~/github.com
GitHub - dghubble/sling: A Go HTTP client library for creating and sending API requests
resource
~/github.com
GitHub - disintegration/imaging: Imaging is a simple image processing package for Go
resource
~/github.com
GitHub - agoalofalife/event: The implementation of the pattern observer
resource
~/github.com
GitHub - golang/glog: Leveled execution logs for Go
resource
~/github.com
GitHub - nikolaydubina/htmljson: 🫐 Rich rendering of JSON as HTML in Go
resource
~/github.com
GitHub - RichardKnop/jsonhal: A simple Go package to make custom structs marshal into HAL compatible JSON responses.
resource
~/github.com
GitHub - carlescere/scheduler: Job scheduling made easy.
resource
~/github.com
GitHub - avahidi/interpol: The "interpol" security string interpolation library and the "police" command line tool. Just moved here from https://bitbucket.org/vahidi/interpol
resource
~/github.com
GitHub - teris-io/log: Structured log interface
resource
~/github.com
GitHub - lucasepe/draft: Generate High Level Cloud Architecture diagrams using YAML syntax.
resource
~/github.com
GitHub - appleboy/gofight: Testing API Handler written in Golang.
resource
~/github.com
GitHub - cihub/seelog: Seelog is a native Go logging library that provides flexible asynchronous dispatching, filtering, and formatting.
resource
~/github.com
GitHub - e154/smart-home: software package for automation
resource
~/github.com
GitHub - apsdehal/go-logger: Simple logger for Go programs. Allows custom formats for messages.
resource
~/github.com
GitHub - krayzpipes/cronticker: Golang ticker that works with Cron scheduling.
resource
~/github.com
GitHub - james-bowman/nlp: Selected Machine Learning algorithms for natural language processing and semantic analysis in Golang
resource
~/github.com
GitHub - o1egl/govatar: Avatar generation library for GO language
resource
~/github.com
GitHub - ssgreg/journald: Go implementation of systemd Journal's native API for logging
resource
~/github.com
GitHub - paypal/gatt: Gatt is a Go package for building Bluetooth Low Energy peripherals
resource
~/github.com
xorm
resource
~/gitea.com
GitHub - cdipaolo/goml: On-line Machine Learning in Go (and so much more)
resource
~/github.com
GitHub - dedalqq/omg.jsonparser: The simple JSON parser with validation by condition
resource
~/github.com
GitHub - soypat/godesim: ODE system solver made simple. For IVPs (initial value problems).
resource
~/github.com
GitHub - go-nunu/nunu: A CLI tool for building Go applications.
resource
~/github.com
GitHub - mbndr/logo: Golang logger to different configurable writers.
resource
~/github.com
GitHub - mozillazg/go-pinyin: 汉字转拼音
resource
~/github.com
GitHub - youthlin/stream: Go Stream, like Java 8 Stream.
resource
~/github.com
GitHub - rafaeljesus/rabbus: A tiny wrapper over amqp exchanges and queues 🚌 ✨
resource
~/github.com
GitHub - ccbrown/api-fu: A collection of Go packages for creating robust GraphQL APIs
resource
~/github.com
GitHub - cabify/logrusiowriter: io.Writer implementation using logrus logger [managed by soy-programador]
resource
~/github.com
GitHub - patrikeh/go-deep: Artificial Neural Network
resource
~/github.com
GitHub - Ullaakut/cameradar: Cameradar hacks its way into RTSP videosurveillance cameras
resource
~/github.com
GitHub - sensorbee/sensorbee: Lightweight stream processing engine for IoT
resource
~/github.com
GitHub - tchayen/triangolatte: 2D triangulation library. Allows translating lines and polygons (both based on points) to the language of GPUs.
resource
~/github.com
GitHub - hpcloud/tail: Go package for reading from continously updated files (tail -f)
resource
~/github.com
GitHub - yuseferi/zax: Zap logger with context
resource
~/github.com
GitHub - arthurkiller/rollingwriter: Rolling writer is an IO util for auto rolling write in go.
resource
~/github.com
GitHub - ewwwwwqm/logdump: Package for multi-level logging
resource
~/github.com
GitHub - vaelen/iot: A Go client for Google IoT Core
resource
~/github.com
Closure Tools  |  Google for Developers
resource
~/developers.google.com
GitHub - tg123/go-htpasswd: Apache htpasswd Parser for Go.
resource
~/github.com
GitHub - limiu82214/gojmapr: get simple struct from complex json
resource
~/github.com
GitHub - abrahambotros/lore: Light Object-Relational Environment (LORE) provides a simple and lightweight pseudo-ORM/pseudo-struct-mapping environment for Go
resource
~/github.com
GitHub - Andrew-M-C/go.jsonvalue: Quick Solution with Unstructured JSON data
resource
~/github.com
GitHub - rk/go-cron: A simple Cron library for go that can execute closures or functions at varying intervals, from once a second to once a year on a specific date and time. Primarily for web applications and long running daemons.
resource
~/github.com
GitHub - rabbitmq/amqp091-go: An AMQP 0-9-1 Go client maintained by the RabbitMQ team. Originally by @streadway: `streadway/amqp`
resource
~/github.com
GitHub - sjwhitworth/golearn: Machine Learning for Go
resource
~/github.com
GitHub - Fs02/grimoire: Database access layer for golang
resource
~/github.com
GitHub - kevinburke/nacl: Pure Go implementation of the NaCL set of API's
resource
~/github.com
GitHub - a8m/rql: Resource Query Language for REST
resource
~/github.com
GitHub - jonoton/scout: Scout is a standalone open source software solution for DIY video security.
resource
~/github.com
GitHub - sebest/logrusly: Loggly Hooks for GO Logrus logger
resource
~/github.com
GitHub - surenderthakran/gomind: A simplistic Neural Network Library in Go
resource
~/github.com
GitHub - c-bata/goptuna: A hyperparameter optimization framework, inspired by Optuna.
resource
~/github.com
GitHub - skanehira/gjo: Small utility to create JSON objects
resource
~/github.com
GitHub - deepaksinghvi/cdule: cdule (pronounce as Schedule) Golang based scheduler library with database support.
resource
~/github.com
GitHub - goml/gobrain: Neural Networks written in go
resource
~/github.com
GitHub - k0kubun/pp: Colored pretty printer for Go language
resource
~/github.com
GitHub - lucassscaravelli/ej: Write and read JSON from different sources in one line
resource
~/github.com
GitHub - osamingo/gaurun-client: Gaurun Client written in Go
resource
~/github.com
GitHub - hashicorp/logutils: Utilities for slightly better logging in Go (Golang).
resource
~/github.com
GitHub - sensepost/gowitness: 🔍 gowitness - a golang, web screenshot utility using Chrome Headless
resource
~/github.com
GitHub - shomali11/gridder: A Grid based 2D Graphics library
resource
~/github.com
GitHub - albrow/jobs: A persistent and flexible background jobs library for go.
resource
~/github.com
GitHub - xfxdev/xlog: plugin architecture and flexible log system for golang
resource
~/github.com
OpenAPI Initiative golang toolkit
resource
~/github.com
GitHub - Xamber/Varis: Golang Neural Network
resource
~/github.com
GitHub - muesli/regommend: Recommendation engine for Go
resource
~/github.com
GitHub - azer/logger: Minimalistic logging library for Go.
resource
~/github.com
GitHub - RichardKnop/machinery: Machinery is an asynchronous task queue/job queue based on distributed message passing.
resource
~/github.com
GitHub - wagslane/go-password-validator: Validate the Strength of a Password in Go
resource
~/github.com
GitHub - reugn/go-quartz: Minimalist and zero-dependency scheduling library for Go
resource
~/github.com
GitHub - recolude/unitpacking: A library for storing unit vectors in a representation that lends itself to saving space on disk.
resource
~/github.com
GitHub - nsqio/go-nsq: The official Go package for NSQ
resource
~/github.com
GitHub - BayesWitnesses/m2cgen: Transform ML models into a native code (Java, C, Python, Go, JavaScript, Visual Basic, C#, R, PowerShell, PHP, Dart, Haskell, Ruby, F#, Rust) with zero dependencies
resource
~/github.com
GitHub - Clivern/Beaver: 💨 A real time messaging system to build a scalable in-app notifications, multiplayer games, chat apps in web and mobile apps.
resource
~/github.com
GitHub - hashicorp/go-getter: Package for downloading things from a string URL using a variety of protocols.
resource
~/github.com
GitHub - elgs/gojq: JSON query in Golang
resource
~/github.com
GitHub - dathoangnd/gonet: Neural Network for Go.
resource
~/github.com
GitHub - fogleman/ln: 3D line art engine.
resource
~/github.com
GitHub - timkaye11/goRecommend: Collaborative Filtering (CF) Algorithms in Go!
resource
~/github.com
GitHub - fanux/lhttp: go websocket, a better way to buid your IM server
resource
~/github.com
GitHub - confluentinc/confluent-kafka-go: Confluent's Apache Kafka Golang client
resource
~/github.com
GitHub - tidwall/gjson: Get JSON values quickly - JSON parser for Go
resource
~/github.com
GitHub - desertbit/glue: Glue - Robust Go and Javascript Socket Library (Alternative to Socket.io)
resource
~/github.com
GitHub - ohler55/ojg: Optimized JSON for Go
resource
~/github.com
GitHub - alexcesaro/log: Logging packages for Go
resource
~/github.com
GitHub - jbrukh/bayesian: Naive Bayesian Classification for Golang.
resource
~/github.com
GitHub - llir/llvm: Library for interacting with LLVM IR in pure Go.
resource
~/github.com
GitHub - koyachi/go-nude: Nudity detection with Go.
resource
~/github.com
GitHub - owulveryck/onnx-go: onnx-go gives the ability to import a pre-trained neural network within Go without being linked to a framework or library.
resource
~/github.com
GitHub - adhocore/gronx: Lightweight, fast and dependency-free Cron expression parser (due checker, next/prev due date finder), task runner, job scheduler and/or daemon for Golang (tested on v1.13+) and standalone usage. If you are bold, use it to replace crontab entirely.
resource
~/github.com
GitHub - miolini/jsonf: Console JSON formatter with query feature
resource
~/github.com
GitHub - reugn/go-streams: A lightweight stream processing library for Go
resource
~/github.com
GitHub - chanify/chanify: Chanify is a safe and simple notification tools. This repository is command line tools for Chanify.
resource
~/github.com
GitHub - daviddengcn/go-pr: Pattern recognition package in Go lang.
resource
~/github.com
GitHub - Fontinalis/fonet: fonet is a deep neural network package for Go.
resource
~/github.com
GitHub - Edgenesis/shifu: Kubernetes-native IoT gateway
resource
~/github.com
GitHub - Pixboost/transformimgs: Open source image CDN.
resource
~/github.com
GitHub - fogleman/pt: A path tracer written in Go.
resource
~/github.com
GitHub - TheCreeper/go-notify: Package notify provides an implementation of the Gnome DBus Notifications Specification.
resource
~/github.com
GitHub - fogleman/gg: Go Graphics - 2D rendering in Go with a simple API.
resource
~/github.com
GitHub - abusomani/jsonhandlers: JSON library to expose simple handlers that lets you easily read and write json from various sources.
resource
~/github.com
GitHub - edoger/zkits-logger: A powerful zero-dependency json logger.
resource
~/github.com
GitHub - ChimeraCoder/gojson: Automatically generate Go (golang) struct definitions from example JSON
resource
~/github.com
GitHub - e-XpertSolutions/go-cluster: k-modes and k-prototypes clustering algorithms implementation in Go
resource
~/github.com
GitHub - firstrow/logvoyage: LogVoyage - logging SaaS written in GoLang
resource
~/github.com
GitHub - uber-go/cadence-client: Framework for authoring workflows and activities running on top of the Cadence orchestration engine.
resource
~/github.com
GitHub - ThePaw/probab: Automatically exported from code.google.com/p/probab
resource
~/github.com
GitHub - ftrvxmtrx/tga: Go package for decoding and encoding TARGA image format
resource
~/github.com
GitHub - go-gorm/gorm: The fantastic ORM library for Golang, aims to be developer friendly
resource
~/github.com
GitHub - lf-edge/ekuiper: Lightweight data stream processing engine for IoT edge
resource
~/github.com
GitHub - pravj/geopattern: :triangular_ruler: Create beautiful generative image patterns from a string in golang.
resource
~/github.com
GitHub - roylee0704/gron: gron, Cron Jobs in Go.
resource
~/github.com
GitHub - mosajjal/dnsmonster: Passive DNS Capture and Monitoring Toolkit
resource
~/github.com
GitHub - olebedev/emitter: Emits events in Go way, with wildcard, predicates, cancellation possibilities and many other good wins
resource
~/github.com
GitHub - samber/slog-multi: 🚨 Design workflows of slog handlers: pipeline, middleware, fanout, routing, failover, load balancing...
resource
~/github.com
GitHub - socifi/jazz: Abstraction layer for simple rabbitMQ connection, messaging and administration
resource
~/github.com
GitHub - pebbe/zmq3: A Go interface to ZeroMQ version 3
resource
~/github.com
GitHub - catchplay/scaffold: Generate scaffold project layout for Go.
resource
~/github.com
GitHub - gyozatech/noodlog: 🍜 Parametrized JSON logging library in Golang which lets you obfuscate sensitive data and marshal any kind of content.
resource
~/github.com
GitHub - sybrexsys/RapidMQ: RapidMQ is a pure, extremely productive, lightweight and reliable library for managing of the local messages queue
resource
~/github.com
GitHub - digitalcrab/browscap_go: GoLang Library for Browser Capabilities Project
resource
~/github.com
GitHub - no-src/log: A simple logging framework out of the box
resource
~/github.com
GitHub - asafschers/goscore: Go Scoring API for PMML
resource
~/github.com
GitHub - haxpax/gosms: :mailbox_closed: Your own local SMS gateway in Go
resource
~/github.com
GitHub - magic003/alice: An additive dependency injection container for Golang.
resource
~/github.com
GitHub - fiam/gounidecode: Unicode transliterator for #golang
resource
~/github.com
GitHub - Fs02/go-todo-backend: Go Todo Backend example using modular project layout for product microservice.
resource
~/github.com
GitHub - romshark/jscan: High performance JSON iterator & validator for Go
resource
~/github.com
GitHub - distatus/battery: cross-platform, normalized battery information library
resource
~/github.com
GitHub - huandu/xstrings: Implements string functions widely used in other languages but absent in Go.
resource
~/github.com
GitHub - AmuzaTkts/jsonapi-errors: Go bindings based on the JSON API errors reference
resource
~/github.com
GitHub - endeveit/enca: Minimal cgo bindings for libenca
resource
~/github.com
GitHub - mudler/anagent: Minimalistic, pluggable Golang evloop/timer handler with dependency-injection
resource
~/github.com
GitHub - Fs02/wire: Strict Runtime Dependency Injection for Golang
resource
~/github.com
GitHub - rs/xlog: xlog is a logger for net/context aware HTTP applications
resource
~/github.com
GitHub - mdlayher/dhcp6: Package dhcp6 implements a DHCPv6 server, as described in RFC 3315. MIT Licensed.
resource
~/github.com
GitHub - PerimeterX/marshmallow: Marshmallow provides a flexible and performant JSON unmarshalling in Go. It specializes in dealing with unstructured struct - when some fields are known and some aren't, with zero performance overhead nor extra coding needed.
resource
~/github.com
GitHub - otiai10/gosseract: Go package for OCR (Optical Character Recognition), by using Tesseract C++ library
resource
~/github.com
GitHub - fterrag/goxlsxwriter: Golang bindings for libxlsxwriter for writing XLSX files
resource
~/github.com
GitHub - lana/go-commandbus: Simple command bus for GO
resource
~/github.com
GitHub - mehdihadeli/Go-MediatR: 🚃 A library for handling mediator patterns and simplified CQRS patterns within an event-driven architecture, inspired by csharp MediatR library.
resource
~/github.com
GitHub - maxatome/go-testdeep: Extremely flexible golang deep comparison, extends the go testing package, tests HTTP APIs and provides tests suite
resource
~/github.com
GitHub - godbus/dbus: Native Go bindings for D-Bus
resource
~/github.com
GitHub - gontainer/gontainer: YAML-based Dependency Injection container for GO
resource
~/github.com
GitHub - davidbyttow/govips: A lightning fast image processing and resizing library for Go
resource
~/github.com
GitHub - bobg/basexx: Convert digit strings between arbitrary bases.
resource
~/github.com
GitHub - anthonynsimon/bild: Image processing algorithms in pure Go
resource
~/github.com
GitHub - steambap/captcha: :sunglasses:Package captcha provides an easy to use, unopinionated API for captcha generation
resource
~/github.com
GitHub - natefinch/lumberjack: lumberjack is a log rolling package for Go
resource
~/github.com
GitHub - asaskevich/EventBus: [Go] Lightweight eventbus with async compatibility for Go
resource
~/github.com
GitHub - wajox/gobase: This is a simple skeleton for golang applications
resource
~/github.com
GitHub - neotoolkit/faker: Fake data generator
resource
~/github.com
GitHub - appleboy/drone-line: Sending line notifications using a binary, docker or Drone CI.
resource
~/github.com
GitHub - gen2brain/go-unarr: Go bindings for unarr (decompression library for RAR, TAR, ZIP and 7z archives)
resource
~/github.com
GitHub - insidieux/inizio: Golang project standard layout generator
resource
~/github.com
GitHub - echocat/slf4g: Simple Logging Facade for Golang
resource
~/github.com
GitHub - kirillDanshin/avgRating: Calculate average score and rating based on Wilson Score Equation
resource
~/github.com
GitHub - hybridgroup/gocv: Go package for computer vision using OpenCV 4 and beyond. Includes support for DNN, CUDA, and OpenCV Contrib.
resource
~/github.com
GitHub - simukti/sqldb-logger: A logger for Go SQL database driver without modifying existing *sql.DB stdlib usage.
resource
~/github.com
GitHub - furdarius/rabbitroutine: Lightweight library that handles RabbitMQ auto-reconnect and publishing retry routine for you.
resource
~/github.com
GitHub - go-ffmt/ffmt: Golang beautify data display for Humans
resource
~/github.com
GitHub - miolini/datacounter: Golang counters for readers/writers
resource
~/github.com
GitHub - disintegration/gift: Go Image Filtering Toolkit
resource
~/github.com
GitHub - olahol/melody: :notes: Minimalist websocket framework for Go
resource
~/github.com
GitHub - Melkeydev/go-blueprint: Go-blueprint allows users to spin up a quick Go project using a popular framework
resource
~/github.com
GitHub - uber-go/zap: Blazing fast, structured, leveled logging in Go.
resource
~/github.com
GitHub - sideshow/apns2: ⚡ HTTP/2 Apple Push Notification Service (APNs) push provider for Go — Send push notifications to iOS, tvOS, Safari and OSX apps, using the APNs HTTP/2 protocol.
resource
~/github.com
GitHub - logrange/linker: Dependency Injection and Inversion of Control package
resource
~/github.com
GitHub - nanomsg/mangos: mangos is a pure Golang implementation of nanomsg's "Scalablilty Protocols"
resource
~/github.com
GitHub - sirupsen/logrus: Structured, pluggable logging for Go.
resource
~/github.com
GitHub - rookii/paicehusk: Golang implementation of the Paice/Husk Stemming Algorithm
resource
~/github.com
GitHub - boot-go/boot: Configuration and dependency injection
resource
~/github.com
GitHub - hawx/img: A selection of image manipulation tools
resource
~/github.com
GitHub - zitryss/go-sample: Go Project Sample Layout
resource
~/github.com
GitHub - siddontang/go-log: a golang log lib supports level and multi handlers
resource
~/github.com
GitHub - alexsniffin/gosd: A library for scheduling when to dispatch a message to a channel
resource
~/github.com
GitHub - lacion/cookiecutter-golang: A Go project template
resource
~/github.com
GitHub - jeroenrinzema/commander: Build event-driven and event streaming applications with ease
resource
~/github.com
GitHub - mdlayher/raw: Package raw enables reading and writing data at the device driver level for a network interface. MIT Licensed.
resource
~/github.com
GitHub - MarvinJWendt/testza: Full-featured test framework for Go! Assertions, fuzzing, input testing, output capturing, and much more! 🍕
resource
~/github.com
GitHub - bobg/encid
resource
~/github.com
GitHub - osamingo/gosh: Provide Go Statistics Handler, Struct, Measure Method
resource
~/github.com
GitHub - clok/kemba: A tiny debug logging tool. Ideal for CLI tools and command applications. Inspired by https://github.com/visionmedia/debug
resource
~/github.com
GitHub - neurosnap/sentences: A multilingual command line sentence tokenizer in Golang
resource
~/github.com
GitHub - joeig/go-powerdns: PowerDNS-Auth API client for Go (community project)
resource
~/github.com
GitHub - a2800276/porter: porter stemmer
resource
~/github.com
GitHub - ozgio/strutil: String utilities for Go
resource
~/github.com
GitHub - omeid/go-resources: Unfancy resources embedding for Go with out of box http.FileSystem support.
resource
~/github.com
GitHub - gotestyourself/gotest.tools: A collection of packages to augment the go testing package and support common patterns.
resource
~/github.com
GitHub - stretchr/testify: A toolkit with common assertions and mocks that plays nicely with the standard library
resource
~/github.com
GitHub - rekby/lets-proxy2: Reverse proxy with automatically obtains TLS certificates from Let's Encrypt
resource
~/github.com
GitHub - jirenius/go-res: RES Service protocol library for Go
resource
~/github.com
GitHub - thoas/picfit: An image resizing server written in Go
resource
~/github.com
GitHub - Logicalis/asn1: Asn.1 BER and DER encoding library for golang.
resource
~/github.com
GitHub - hashicorp/mdns: Simple mDNS client/server library in Golang
resource
~/github.com
GitHub - yanyiwu/gojieba: "结巴"中文分词的Golang版本
resource
~/github.com
GitHub - artyom/autoflags: Populate go command line app flags from config struct
resource
~/github.com
GitHub - leaanthony/debme: embed.FS wrapper providing additional functionality
resource
~/github.com
GitHub - octomation/go-module: 🧩 Template for a typical module written on Go.
resource
~/github.com
GitHub - gonum/plot: A repository for plotting and visualizing data
resource
~/github.com
GitHub - soypat/rebed: Recreates directory and files from embedded filesystem using Go 1.16 embed.FS type.
resource
~/github.com
GitHub - timsolov/rest-query-parser: Query Parser for REST
resource
~/github.com
GitHub - goodsign/libtextcat: Cgo binding for libtextcat C library
resource
~/github.com
GitHub - ddymko/go-jsonerror: Small package which wraps error responses to follow jsonapi.org
resource
~/github.com
GitHub - phuslu/log: Fastest structured logging
resource
~/github.com
GitHub - rsjethani/secret: Prevent your secrets from leaking into logs, std* etc.
resource
~/github.com
GitHub - ssh-vault/ssh-vault: 🌰 encrypt/decrypt using ssh keys
resource
~/github.com
GitHub - matryer/is: Professional lightweight testing mini-framework for Go.
resource
~/github.com
GitHub - maxatome/go-vitotrol: golang client library to Viessmann Vitotrol web service
resource
~/github.com
GitHub - ndabAP/assocentity: Package assocentity returns the mean distance from tokens to an entity and its synonyms
resource
~/github.com
GitHub - nytlabs/streamtools: tools for working with streams of data
resource
~/github.com
GitHub - smartystreets/goconvey: Go testing in the browser. Integrates with `go test`. Write behavioral tests in Go.
resource
~/github.com
GitHub - gogo/protobuf: [Deprecated] Protocol Buffers for Go with Gadgets
resource
~/github.com
GitHub - tools/godep: dependency tool for go
resource
~/github.com
GitHub - franela/goblin: Minimal and Beautiful Go testing framework
resource
~/github.com
GitHub - owenthereal/nut: Vendor Go dependencies
resource
~/github.com
GitHub - go-restit/restit: A Go library help testing your RESTful API application
resource
~/github.com
GitHub - hlandau/acmetool: :lock: acmetool, an automatic certificate acquisition tool for ACME (Let's Encrypt)
resource
~/github.com
GitHub - vardius/gocontainer: Simple Dependency Injection Container
resource
~/github.com
GitHub - rhosocial/go-dag: A Go-based framework has been developed to oversee the execution of workflows delineated by directed acyclic graphs (DAGs).
resource
~/github.com
GitHub - ccding/go-stun: A go implementation of the STUN client (RFC 3489 and RFC 5389)
resource
~/github.com
GitHub - cheshir/go-mq: Declare AMQP entities like queues, producers, and consumers in a declarative way. Can be used to work with RabbitMQ.
resource
~/github.com
GitHub - antchfx/antch: Antch, a fast, powerful and extensible web crawling & scraping framework for Go
resource
~/github.com
GitHub - jolestar/go-commons-pool: a generic object pool for golang
resource
~/github.com
GitHub - mgutz/logxi: A 12-factor app logger built for performance and happy development
resource
~/github.com
GitHub - xcodersun/eywa: Make IoT a lot more fun with data.
resource
~/github.com
GitHub - raja/argon2pw: Argon2 password hashing package for go with constant time hash comparison
resource
~/github.com
GitHub - kirillDanshin/llb
resource
~/github.com
GitHub - ChristopherRabotin/ode: An ordinary differential equation solving library in golang.
resource
~/github.com
GitHub - kubeservice-stack/common: golang common library
resource
~/github.com
GitHub - danieldk/go2vec: Read and use word2vec vectors in Go
resource
~/github.com
GitHub - pjebs/optimus-go: ID hashing and Obfuscation using Knuth's Algorithm
resource
~/github.com
GitHub - gorgonia/gorgonia: Gorgonia is a library that helps facilitate machine learning in Go.
resource
~/github.com
GitHub - 99designs/gqlgen: go generate based graphql server library
resource
~/github.com
GitHub - dedalqq/omg.testingtools: This tool can be useful for writing a tests. If you want change private field in struct from imported libraries than it can help you.
resource
~/github.com
GitHub - technohippy/go-glmatrix: go-glmatrix is a golang version of glMatrix, which is "designed to perform vector and matrix operations stupidly fast".
resource
~/github.com
GitHub - sirupsen/logrus: Structured, pluggable logging for Go.
resource
~/github.com
GitHub - mavihq/persian: Some utilities for Persian language in Go (Golang)
resource
~/github.com
GitHub - jdkato/prose: :book: A Golang library for text processing, including tokenization, part-of-speech tagging, and named-entity extraction.
resource
~/github.com
GitHub - DarthPestilane/easytcp: :sparkles: EasyTCP is a light-weight TCP framework written in Go (Golang), built with message router. EasyTCP helps you build a TCP server easily fast and less painful.
resource
~/github.com
GitHub - arch-go/arch-go: Architecture checks for Go projects
resource
~/github.com
GitHub - pion/webrtc: Pure Go implementation of the WebRTC API
resource
~/github.com
GitHub - commander-cli/commander: Test your command line interfaces on windows, linux and osx and nodes viá ssh and docker
resource
~/github.com
GitHub - VividCortex/gohistogram: Streaming approximate histograms in Go
resource
~/github.com
GitHub - pieterclaerhout/go-log: A logging library with strack traces, object dumping and optional timestamps
resource
~/github.com
GitHub - structy/log: A simple to use log system, minimalist but with features for debugging and differentiation of messages
resource
~/github.com
GitHub - dunglas/mercure: 🪽 An open, easy, fast, reliable and battery-efficient solution for real-time communications
resource
~/github.com
GitHub - udhos/jazigo: Jazigo is a tool written in Go for retrieving configuration for multiple devices, similar to rancid, fetchconfig, oxidized, Sweet.
resource
~/github.com
GitHub - afjoseph/RAKE.Go: A Go port of the Rapid Automatic Keyword Extraction algorithm (RAKE)
resource
~/github.com
GitHub - uniqush/uniqush-push: Uniqush is a free and open source software system which provides a unified push service for server side notification to apps on mobile devices.
resource
~/github.com
GitHub - gookit/slog: 📑 Lightweight, configurable, extensible logging library written in Go. Support multi level, multi outputs and built-in multi file logger, buffers, clean, rotate-file handling.一个易于使用的，轻量级、可配置、可扩展的日志库。支持多个级别，输出到多文件；内置文件日志处理、自动切割、清理、压缩等增强功能
resource
~/github.com
GitHub - sbabiv/rmqconn: RabbitMQ Reconnection client
resource
~/github.com
GitHub - golang/protobuf: Go support for Google's protocol buffers
resource
~/github.com
GitHub - leandro-lugaresi/hub: :incoming_envelope: A fast Message/Event Hub using publish/subscribe pattern with support for topics like* rabbitMQ exchanges for Go applications
resource
~/github.com
GitHub - pote/gpm: Barebones dependency manager for Go.
resource
~/github.com
GitHub - vtopc/epoch: Contains primitives for marshaling/unmarshaling Unix timestamp/epoch to/from built-in time.Time type in JSON
resource
~/github.com
GitHub - marlow/marlow: persistence layer code generation for golang
resource
~/github.com
GitHub - gonum/gonum: Gonum is a set of numeric libraries for the Go programming language. It contains libraries for matrices, statistics, optimization, and more
resource
~/github.com
GitHub - alexsergivan/transliterator: Golang text Transliterator (i.e München -> Muenchen)
resource
~/github.com
GitHub - blind-oracle/nginx-prometheus: Turn Nginx logs into Prometheus metrics
resource
~/github.com
GitHub - jimlambrt/gldap: Build LDAP services w/ Go
resource
~/github.com
GitHub - TomWright/dasel: Select, put and delete data from JSON, TOML, YAML, XML and CSV files with a single tool. Supports conversion between formats and can be used as a Go package.
resource
~/github.com
GitHub - heedy/heedy: An aggregator for personal metrics, and an extensible analysis engine
resource
~/github.com
GitHub - roadrunner-server/roadrunner: 🤯 High-performance PHP application server, process manager written in Go and powered with plugins
resource
~/github.com
GitHub - flipt-io/flipt: Enterprise-ready, GitOps enabled, CloudNative feature management solution
resource
~/github.com
GitHub - ungerik/go-cairo: Go binding for the cairo graphics library
resource
~/github.com
GitHub - gkampitakis/go-snaps: Jest-like snapshot testing in Go 📸
resource
~/github.com
GitHub - szyhf/go-excel: A simple and light excel file reader to read a standard excel as a table faster | 一个轻量级的Excel数据读取库，用一种更`关系数据库`的方式解析Excel。
resource
~/github.com
GitHub - robinjoseph08/redisqueue: redisqueue provides a producer and consumer of a queue that uses Redis streams
resource
~/github.com
GitHub - neotoolkit/openapi: OpenAPI 3.x parser
resource
~/github.com
GitHub - alexliesenfeld/health: A simple and flexible health check library for Go.
resource
~/github.com
GitHub - containrrr/shoutrrr: Notification library for gophers and their furry friends.
resource
~/github.com
GitHub - dwin/goSecretBoxPassword: 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.
resource
~/github.com
GitHub - lunny/gop: Moved to https://gitea.com/lunny/gop
resource
~/github.com
GitHub - utahta/go-cronowriter: Time based rotating file writer
resource
~/github.com
GitHub - hybridgroup/gobot: Golang framework for robotics, drones, and the Internet of Things (IoT)
resource
~/github.com
GitHub - krotik/dudeldu: A simple SHOUTcast server.
resource
~/github.com
GitHub - blevesearch/segment: A Go library for performing Unicode Text Segmentation as described in Unicode Standard Annex #29
resource
~/github.com
GitHub - tealeg/xlsx: Go library for reading and writing XLSX files.
resource
~/github.com
GitHub - gorse-io/gorse: Gorse open source recommender system engine
resource
~/github.com
GitHub - cloudwego/netpoll: A high-performance non-blocking I/O networking framework focusing on RPC scenarios.
resource
~/github.com
GitHub - charmbracelet/wish: Make SSH apps, just like that! 💫
resource
~/github.com
GitHub - hibiken/asynq: Simple, reliable, and efficient distributed task queue in Go
resource
~/github.com
GitHub - malaschitz/randomForest: Random Forest implementation in golang
resource
~/github.com
GitHub - dchest/stemmer: Stemmer packages for Go programming language. Includes English, German and Dutch stemmers.
resource
~/github.com
GitHub - dveselov/mystem: CGo bindings to Yandex.Mystem
resource
~/github.com
GitHub - songgao/ether: A Go package for sending and receiving ethernet frames. Currently supporting Linux, Freebsd, and OS X.
resource
~/github.com
GitHub - wangyoucao577/go-project-layout: My understanding of how to structure a golang project.
resource
~/github.com
GitHub - google/gnxi: gNXI Tools - gRPC Network Management/Operations Interface Tools
resource
~/github.com
GitHub - mainflux/mainflux: Industrial IoT Messaging and Device Management Platform
resource
~/github.com
GitHub - HnH/di: DI container library that is focused on clean API and flexibility.
resource
~/github.com
GitHub - samber/do: ⚙️ A dependency injection toolkit based on Go 1.18+ Generics.
resource
~/github.com
GitHub - cpmech/gosl: Linear algebra, eigenvalues, FFT, Bessel, elliptic, orthogonal polys, geometry, NURBS, numerical quadrature, 3D transfinite interpolation, random numbers, Mersenne twister, probability distributions, optimisation, differential equations.
resource
~/github.com
GitHub - rakyll/statik: Embed files into a Go executable
resource
~/github.com
GitHub - rs/zerolog: Zero Allocation JSON Logger
resource
~/github.com
GitHub - jaredfolkins/badactor: BadActor.org An in-memory application driven jailer written in Go
resource
~/github.com
GitHub - presbrey/go-multiproxy: Go HTTP client w/ HTTPS and SOCKS5 Proxy Load-balancing, Failover, Retries, Authentication, and RoundTripper
resource
~/github.com
GitHub - madflojo/testcerts: Dynamically generate self-signed certificates and certificate authorities for Go tests
resource
~/github.com
GitHub - DrmagicE/gmqtt: Gmqtt is a flexible, high-performance MQTT broker library that fully implements the MQTT protocol V3.x and V5 in golang
resource
~/github.com
t/cmd/xtemplate at main · youthlin/t
resource
~/github.com
GitHub - thoj/go-galib: Genetic Algorithms library written in Go / golang
resource
~/github.com
GitHub - chzyer/logex: An golang log lib, supports tracking and level, wrap by standard log lib
resource
~/github.com
GitHub - milosgajdos/go-estimate: State estimation and filtering algorithms in Go
resource
~/github.com
GitHub - wzshiming/httpproxy: HTTP proxy handler and dialer
resource
~/github.com
GitHub - NVIDIA/gontainer: Dependency Injection container for Golang projects.
resource
~/github.com
GitHub - go-ego/gse: Go efficient multilingual NLP and text segmentation; support English, Chinese, Japanese and others.
resource
~/github.com
GitHub - go-kata/kinit: GO Dependency Injection
resource
~/github.com
GitHub - stesla/gospecify: A BDD library for Go
resource
~/github.com
GitHub - go-xkg/xkg: User level X Keyboard Grabber
resource
~/github.com
GitHub - Allenxuxu/gev: 🚀Gev is a lightweight, fast non-blocking TCP network library / websocket server based on Reactor mode. Support custom protocols to quickly and easily build high-performance servers.
resource
~/github.com
GitHub - ulikunitz/xz: Pure golang package for reading and writing xz-compressed files
resource
~/github.com
GitHub - opus-domini/fast-shot: Hit your API targets with rapid-fire precision using Go's fastest and simple HTTP Client.
resource
~/github.com
GitHub - zerosnake0/jzon: A golang json library inspired by jsoniter
resource
~/github.com
GitHub - cunicu/gont: A Go testing framework for distributed applications
resource
~/github.com
GitHub - ian-kent/linkio: Simulate network link speed
resource
~/github.com
GitHub - gyuho/goraph: Package goraph implements graph data structure and algorithms.
resource
~/github.com
GitHub - ikawaha/kagome: Self-contained Japanese Morphological Analyzer written in pure Go
resource
~/github.com
GitHub - nkmr-jp/zl: 🧑‍💻 High Developer Experience, zap based logger. It offers rich functionality but is easy to configure and allows the user to choose the best output format for their purposes.
resource
~/github.com
GitHub - gosuri/go-store: A simple and fast Redis backed key-value store library for Go
resource
~/github.com
GitHub - cstockton/go-conv: Fast conversions across various Go types with a simple API.
resource
~/github.com
GitHub - lrita/numa: NUMA is a utility library, which is written in go. It help us to write some NUMA-AWARED code.
resource
~/github.com
GitHub - gobeam/stringy: Convert string to camel case, snake case, kebab case / slugify, custom delimiter, pad string, tease string and many other functionalities with help of by Stringy package.
resource
~/github.com
GitHub - subchen/go-log: Simple and configurable Logging in Go, with level, formatters and writers
resource
~/github.com
GitHub - googollee/go-socket.io: socket.io library for golang, a realtime application framework.
resource
~/github.com
GitHub - glycerine/go-capnproto: Cap'n Proto library and parser for go. This is go-capnproto-1.0, and does not have rpc. See https://github.com/zombiezen/go-capnproto2 for 2.0 which has rpc and capabilities.
resource
~/github.com
GitHub - firasdarwish/ore: Lightweight, generic & simple dependency injection (DI) container for Go
resource
~/github.com
GitHub - aofei/sandid: Every grain of sand on Earth has its own ID.
resource
~/github.com
GitHub - benbjohnson/ego: An ERB-style templating language for Go.
resource
~/github.com
GitHub - pavlo/gosuite: Test suites support for standard Go1.7 "testing" by leveraging Subtests feature
resource
~/github.com
GitHub - xujiajun/gotokenizer: A tokenizer based on the dictionary and Bigram language models for Go. (Now only support chinese segmentation)
resource
~/github.com
GitHub - ake-persson/mapslice-json: Go MapSlice for ordered marshal/ unmarshal of maps in JSON
resource
~/github.com
GitHub - ent/ent: An entity framework for Go
resource
~/github.com
GitHub - icza/bitio: Optimized bit-level Reader and Writer for Go.
resource
~/github.com
GitHub - rafaeljesus/nsq-event-bus: A tiny wrapper around NSQ topic and channel :rocket:
resource
~/github.com
GitHub - tomcraven/goga: Golang Genetic Algorithm
resource
~/github.com
GitHub - elgs/jsonql: JSON query expression library in Golang.
resource
~/github.com
GitHub - kardianos/govendor: Use Go Modules.
resource
~/github.com
GitHub - osrg/gobgp: BGP implemented in the Go Programming Language
resource
~/github.com
GitHub - james-bowman/sparse: Sparse matrix formats for linear algebra supporting scientific and machine learning applications
resource
~/github.com
GitHub - TIBCOSoftware/flogo: Project Flogo is an open source ecosystem of opinionated event-driven capabilities to simplify building efficient & modern serverless functions, microservices & edge apps.
resource
~/github.com
GitHub - soypat/natiu-mqtt: A dead-simple, extensible MQTT implementation well suited for embedded systems.
resource
~/github.com
GitHub - lajosbencz/glo: Logging library for Golang
resource
~/github.com
GitHub - nlpodyssey/spago: Self-contained Machine Learning and Natural Language Processing library in Go
resource
~/github.com
GitHub - lesismal/nbio: Pure Go 1000k+ connections solution, support tls/http1.x/websocket and basically compatible with net/http, with high-performance and low memory cost, non-blocking, event-driven, easy-to-use.
resource
~/github.com
GitHub - cocoonspace/dynjson: Client-customizable JSON formats for dynamic APIs
resource
~/github.com
GitHub - jcuga/golongpoll: golang long polling library. Makes web pub-sub easy via HTTP long-poll servers and clients :coffee: :computer:
resource
~/github.com
GitHub - go-playground/statics: :file_folder: Embeds static resources into go files for single binary compilation + works with http.FileSystem + symlinks
resource
~/github.com
GitHub - xtaci/kcp-go: A Crypto-Secure Reliable-UDP Library for golang with FEC
resource
~/github.com
GitHub - PIMPfiction/govader_backend: Sentimental Analysis Microservice
resource
~/github.com
GitHub - anacrolix/utp: Use anacrolix/go-libutp instead
resource
~/github.com
GitHub - xxjwxc/gormt: database to golang struct
resource
~/github.com
GitHub - IBM/sarama: Sarama is a Go library for Apache Kafka.
resource
~/github.com
GitHub - danhper/structomap: Easily and dynamically generate maps from Go static structures
resource
~/github.com
GitHub - teris-io/shortid: Super short, fully unique, non-sequential and URL friendly Ids
resource
~/github.com
GitHub - go-co-op/gocron: Easy and fluent Go cron scheduling. This is a fork from https://github.com/jasonlvhit/gocron
resource
~/github.com
GitHub - jinyeom/neat: NEAT (NeuroEvolution of Augmenting Topologies) implemented in Go
resource
~/github.com
GitHub - yl2chen/cidranger: Fast IP to CIDR lookup in Golang
resource
~/github.com
GitHub - danieldk/golinear: liblinear bindings for Go
resource
~/github.com
GitHub - stanipetrosyan/go-eventbus: Event Bus package for Go
resource
~/github.com
GitHub - go-the-way/exl: Excel binding to struct written in Go.(Only supports Go1.18+)
resource
~/github.com
GitHub - dimiro1/banner: An easy way to add useful startup banners into your Go applications
resource
~/github.com
GitHub - OGFris/GoStats: GoStats is a go library for math statistics mostly used in ML domains, it covers most of the statistical measures functions.
resource
~/github.com
GitHub - dimiro1/health: An easy to use, extensible health check library for Go applications.
resource
~/github.com
GitHub - ardanlabs/service: Starter-kit for writing services in Go using Kubernetes.
resource
~/github.com
GitHub - gojek/darkroom
resource
~/github.com
GitHub - vardius/message-bus: Go simple async message bus
resource
~/github.com
GitHub - maddyblue/go-dsp: Digital Signal Processing for Go
resource
~/github.com
GitHub - c-robinson/iplib: A library for working with IP addresses and networks in Go
resource
~/github.com
GitHub - yourbasic/graph: Graph algorithms and data structures
resource
~/github.com
GitHub - Wing924/hostutils: A golang library for packing and unpacking hosts list
resource
~/github.com
GitHub - hlandau/passlib: :key: Idiotproof golang password validation library inspired by Python's passlib
resource
~/github.com
GitHub - logur/logur: Logur is an opinionated collection of logging best practices
resource
~/github.com
GitHub - semihalev/sdns: A high-performance, recursive DNS resolver server with DNSSEC support, focused on preserving privacy.
resource
~/github.com
GitHub - smancke/guble: websocket based messaging server written in golang
resource
~/github.com
GitHub - hyperonym/ratus: Ratus is a RESTful asynchronous task queue server. It translated concepts of distributed task queues into a set of resources that conform to REST principles and provides a consistent HTTP API for various backends.
resource
~/github.com
GitHub - amoghe/distillog: Logging, distilled
resource
~/github.com
GitHub - zhulongcheng/testsql: Generate test data from SQL files before testing and clear it after finished.
resource
~/github.com
GitHub - go-gl/glfw: Go bindings for GLFW 3
resource
~/github.com
GitHub - go-ozzo/ozzo-log: A Go (golang) package providing high-performance asynchronous logging, message filtering by severity and category, and multiple message targets.
resource
~/github.com
GitHub - lmittmann/tint: 🌈 slog.Handler that writes tinted (colorized) logs
resource
~/github.com
GitHub - whitaker-io/machine: Machine is a workflow/pipeline library for processing data
resource
~/github.com
GitHub - aofei/cameron: An avatar generator for Go.
resource
~/github.com
GitHub - h2non/bimg: Go package for fast high-level image processing powered by libvips C library
resource
~/github.com
GitHub - ricardolonga/jsongo: Fluent API to make it easier to create Json objects.
resource
~/github.com
GitHub - jfcg/yell: :ledger: Yet another minimalist logging library
resource
~/github.com
GitHub - vksnk/go-fann: Go bindings for FANN, library for artificial neural networks
resource
~/github.com
GitHub - uber-go/dig: A reflection based dependency injection toolkit for Go.
resource
~/github.com
GitHub - samber/slog-formatter: 🚨 slog: Attribute formatting
resource
~/github.com
GitHub - go-playground/stats: :chart_with_upwards_trend: Monitors Go MemStats + System stats such as Memory, Swap and CPU and sends via UDP anywhere you want for logging etc...
resource
~/github.com
GitHub - awsong/MMSEGO: Chinese word splitting algorithm MMSEG in GO
resource
~/github.com
GitHub - mingard/sitemap-format: Simple sitemap formatting, with a little syntactic sugar
resource
~/github.com
GitHub - hillu/go-yara: Go bindings for YARA
resource
~/github.com
GitHub - polera/publicip: Go pkg for returning your public facing IP address.
resource
~/github.com
GitHub - xtaci/gaio: High performance minimalism async-io(proactor) networking for Golang.
resource
~/github.com
GitHub - elithrar/simple-scrypt: A convenience library for generating, comparing and inspecting password hashes using the scrypt KDF in Go 🔑
resource
~/github.com
GitHub - kpango/glg: Simple and blazing fast lockfree logging library for golang
resource
~/github.com
GitHub - datarootsio/cheek: cheek: a pico-sized declarative job scheduler
resource
~/github.com
GitHub - valyala/fasttemplate: Simple and fast template engine for Go
resource
~/github.com
GitHub - knights-analytics/hugot: Huggingface transformer pipelines in Golang
resource
~/github.com
GitHub - muir/nject: Golang type-safe dependency injection
resource
~/github.com
LINEヤフー for Business｜LINEヤフーが提供する法人向けサービス
resource
~/at.line.me
GitHub - easegress-io/easegress: A Cloud Native traffic orchestration system
resource
~/github.com
GitHub - brianvoe/gofakeit: Random fake data generator written in go
resource
~/github.com
GitHub - pariz/gountries: Gountries provides: Countries (ISO-3166-1), Country Subdivisions(ISO-3166-2), Currencies (ISO 4217), Geo Coordinates(ISO-6709) as well as translations, country borders and other stuff exposed as struct data.
resource
~/github.com
GitHub - eduardonunesp/sslb: Golang Super Simple Load Balance
resource
~/github.com
GitHub - goioc/di: Simple and yet powerful Dependency Injection for Go
resource
~/github.com
GitHub - francoispqt/onelog: Dead simple, super fast, zero allocation logger for Golang
resource
~/github.com
GitHub - lampctl/go-sse: Go package for sending and receiving SSE (server-sent events)
resource
~/github.com
GitHub - kzahedi/goent: GO Implementation of Entropy Measures
resource
~/github.com
GitHub - dwin/goArgonPass: goArgonPass is a Argon2 Password utility package for Go using the crypto library package Argon2 designed to be compatible with Passlib for Python and Argon2 PHP. Argon2 was the winner of the most recent Password Hashing Competition. This is designed for use anywhere password hashing and verification might be needed and is intended to replace implementations using bcrypt or Scrypt.
resource
~/github.com
GitHub - youthlin/t: t: translation util for go, using GNU gettext
resource
~/github.com
GitHub - avelino/slugify: A Go slugify application that handles string
resource
~/github.com
GitHub - qiniu/goc: A Comprehensive Coverage Testing System for The Go Programming Language
resource
~/github.com
GitHub - aldor007/mort: Storage and image processing server written in Go
resource
~/github.com
GitHub - alwindoss/morse: Morse Code Library in Go
resource
~/github.com
GitHub - aphistic/gomol: Gomol is a library for structured, multiple-output logging for Go with extensible logging outputs
resource
~/github.com
GitHub - ysmood/got: An enjoyable golang test framework.
resource
~/github.com
GitHub - vcaesar/tt: Simple and colorful test tools
resource
~/github.com
GitHub - hmdsefi/gograph: A golang generic graph library that provides mathematical graph-theory and algorithms.
resource
~/github.com
GitHub - sethgrid/pester: Go (golang) http calls with retries and backoff
resource
~/github.com
GitHub - ThundR67/straf: Convert Golang Struct To GraphQL Object On The Fly
resource
~/github.com
GitHub - petejkim/goop: A simple dependency manager for Go (golang), inspired by Bundler.
resource
~/github.com
GitHub - teler-sh/teler-waf: teler-waf is a Go HTTP middleware that protects local web services from OWASP Top 10 threats, known vulnerabilities, malicious actors, botnets, unwanted crawlers, and brute force attacks.
resource
~/github.com
GitHub - pebbe/textcat: A Go package for n-gram based text categorization, with support for utf-8 and raw text
resource
~/github.com
GitHub - sanbornm/mp: Simple Email Parser
resource
~/github.com
GitHub - jonreiter/govader: vader sentiment analysis in go
resource
~/github.com
GitHub - google/wire: Compile-time Dependency Injection for Go
resource
~/github.com
GitHub - mdlayher/arp: Package arp implements the ARP protocol, as described in RFC 826. MIT Licensed.
resource
~/github.com
GitHub - nicklaw5/go-respond: A Go package for handling common HTTP JSON responses.
resource
~/github.com
GitHub - henvic/httpretty: Package httpretty prints the HTTP requests you make with Go pretty on your terminal.
resource
~/github.com
GitHub - aerogo/packet: :package: Send network packets over a TCP or UDP connection.
resource
~/github.com
GitHub - schollz/peerdiscovery: Pure-Go library for cross-platform local peer discovery using UDP multicast :repeat: :woman:
resource
~/github.com
GitHub - nikolaydubina/calendarheatmap: 📅 Calendar heatmap inspired by GitHub contribution activity
resource
~/github.com
GitHub - ThreeDotsLabs/watermill: Building event-driven applications the easy way in Go.
resource
~/github.com
GitHub - pioz/faker: Random fake data and struct generator for Go.
resource
~/github.com
GitHub - vdobler/chart: Provide basic charts in go
resource
~/github.com
GitHub - hackebrot/turtle: Emojis for Go 😄🐢🚀
resource
~/github.com
GitHub - ThePaw/go-gt: Automatically exported from code.google.com/p/go-gt
resource
~/github.com
GitHub - google/gopacket: Provides packet processing capabilities for Go
resource
~/github.com
GitHub - cheng-zhongliang/event: Simple I/O event notification library wirtten in Golang
resource
~/github.com
GitHub - lim-yoona/tcpack: tcpack is an application protocol based on TCP to Pack and Unpack bytes stream in go program.
resource
~/github.com
GitHub - hashicorp/go-retryablehttp: Retryable HTTP client in Go
resource
~/github.com
GitHub - google/go-cmp: Package for comparing Go values in tests
resource
~/github.com
GitHub - earthboundkid/be: The Go test helper for minimalists
resource
~/github.com
GitHub - openflagr/flagr: Flagr is a feature flagging, A/B testing and dynamic configuration microservice
resource
~/github.com
GitHub - antham/gommit: Enforce git message commit consistency
resource
~/github.com
GitHub - hyperboloide/pdfgen: HTTP service to generate PDF from Json requests
resource
~/github.com
GitHub - lucasepe/modgv: Converts 'go mod graph' output into Graphviz's DOT language
resource
~/github.com
happy/pkg/strings/bexp at main · happy-sdk/happy
resource
~/github.com
GitHub - valyala/fastjson: Fast JSON parser and validator for Go. No custom structs, no code generation, no reflection
resource
~/github.com
GitHub - adrianosela/sslmgr: A layer of abstraction the around acme/autocert certificate manager (Golang)
resource
~/github.com
GitHub - rylans/getlang: Natural language detection package in pure Go
resource
~/github.com
GitHub - VividCortex/ewma: Exponentially Weighted Moving Average algorithms for Go.
resource
~/github.com
GitHub - davecgh/go-spew: Implements a deep pretty printer for Go data structures to aid in debugging
resource
~/github.com
GitHub - gliderlabs/ssh: Easy SSH servers in Golang
resource
~/github.com
GitHub - cabify/gotoprom: Type-safe Prometheus metrics builder library for golang [managed by soy-programador]
resource
~/github.com
GitHub - tmc/graphql: graphql parser + utilities
resource
~/github.com
GitHub - CloudyKit/jet: Jet template engine
resource
~/github.com
GitHub - gojek/heimdall: An enhanced HTTP client for Go
resource
~/github.com
GitHub - ryanbressler/CloudForest: Ensembles of decision trees in go/golang.
resource
~/github.com
GitHub - jorelosorio/spellingcorrector: Spelling corrector for Spanish language
resource
~/github.com
GitHub - kamilsk/tracer: 🪡 Dead simple, lightweight tracing.
resource
~/github.com
GitHub - blind-oracle/psql-streamer: Stream database events from PostgreSQL to Kafka
resource
~/github.com
GitHub - maddyblue/esc: A simple file embedder for Go
resource
~/github.com
GitHub - rjohnsondev/golibstemmer: Go bindings for the snowball libstemmer library including porter 2
resource
~/github.com
GitHub - sgrodriguez/ddt: Golang Dynamic Decision Tree
resource
~/github.com
GitHub - golobby/container: A lightweight yet powerful IoC dependency injection container for the Go programming language
resource
~/github.com
GitHub - nicksnyder/go-i18n: Translate your Go program into multiple languages.
resource
~/github.com
GitHub - galeone/tfgo: Tensorflow + Go, the gopher way
resource
~/github.com
GitHub - i-love-flamingo/dingo: Go Dependency Injection Framework
resource
~/github.com
GitHub - mozillazg/go-slugify: Pretty Slug.
resource
~/github.com
GitHub - simonnilsson/ask: A Go package that provides a simple way of accessing nested properties in maps and slices.
resource
~/github.com
GitHub - two/tspool: tcp server pool
resource
~/github.com
GitHub - mholt/archiver: Easily create & extract archives, and compress & decompress files of various formats
resource
~/github.com
GitHub - panjf2000/gnet: 🚀 gnet is a high-performance, lightweight, non-blocking, event-driven networking framework written in pure Go.
resource
~/github.com
GitHub - sunwxg/goshark
resource
~/github.com
GitHub - trickstercache/trickster: Open Source HTTP Reverse Proxy Cache and Time Series Dashboard Accelerator
resource
~/github.com
GitHub - xfxdev/xtcp: A TCP Server Framework with graceful shutdown, custom protocol.
resource
~/github.com
GitHub - msoap/go-carpet: Tool for show test coverage in terminal for Go source files
resource
~/github.com
GitHub - m1/gospin: Article spinning and spintax/spinning syntax engine written in Go, useful for A/B, testing pieces of text/articles and creating more natural conversations
resource
~/github.com
GitHub - ghostiam/binstruct: Golang binary decoder for mapping data into the structure
resource
~/github.com
GitHub - suzuki-shunsuke/flute: Golang HTTP client testing framework
resource
~/github.com
GitHub - hashicorp/mql: Model Query Language (mql) is a query language for your database models.
resource
~/github.com
GitHub - viant/dsunit: Datastore Testibility
resource
~/github.com
GitHub - steebchen/prisma-client-go: Prisma Client Go is an auto-generated and fully type-safe database client
resource
~/github.com
GitHub - khezen/evoli: Genetic Algorithm and Particle Swarm Optimization
resource
~/github.com
GitHub - golang-templates/seed: Go application GitHub repository template.
resource
~/github.com
GitHub - amimof/huego: An extensive Philips Hue client library for Go with an emphasis on simplicity
resource
~/github.com
generators/varhandler at master · azr/generators
resource
~/github.com
GitHub - gosimple/slug: URL-friendly slugify with multiple languages support.
resource
~/github.com
GitHub - csweichel/bel: Generate TypeScript interfaces from Go structs/interfaces - useful for JSON RPC
resource
~/github.com
GitHub - dailymotion/oplog: A generic oplog/replication system for microservices
resource
~/github.com
GitHub - unidoc/unioffice: Pure go library for creating and processing Office Word (.docx), Excel (.xlsx) and Powerpoint (.pptx) documents
resource
~/github.com
GitHub - madflojo/tasks: Package tasks is an easy to use in-process scheduler for recurring tasks in Go
resource
~/github.com
GitHub - sbourlon/go-lctree: go-lctree provides a CLI and Go primitives to serialize and deserialize LeetCode binary trees (e.g. "[5,4,7,3,null,2,null,-1,null,9]").
resource
~/github.com
GitHub - shurcooL/vfsgen: Takes an input http.FileSystem (likely at go generate time) and generates Go code that statically implements it.
resource
~/github.com
GitHub - posener/wstest: go websocket client for unit testing of a websocket handler
resource
~/github.com
Home
resource
~/github.com
GitHub - neilotoole/jsoncolor: Colorized JSON output for Go
resource
~/github.com
GitHub - leozz37/hare: 🐇 CLI tool for websockets and Go package
resource
~/github.com
GitHub - koofr/graval: An experimental go FTP server framework
resource
~/github.com
GitHub - pascaldekloe/metrics: atomic measures + Prometheus exposition library
resource
~/github.com
GitHub - glycerine/bambam: auto-generate capnproto schema from your golang source files. Depends on go-capnproto-1.0 at https://github.com/glycerine/go-capnproto
resource
~/github.com
GitHub - saleh-rahimzadeh/go-words: A words table and text resource library for Golang projects.
resource
~/github.com
GitHub - yahoo/vssh: Go Library to Execute Commands Over SSH at Scale
resource
~/github.com
GitHub - hofstadter-io/frisby: API testing framework inspired by frisby-js
resource
~/github.com
GitHub - earthboundkid/requests: HTTP requests for Gophers
resource
~/github.com
IP Geolocation API | IP2Location.io
resource
~/www.ip2location.io
GitHub - emersion/go-vcard: A Go library to parse and format vCard
resource
~/github.com
Labeled Tab-separated Values (LTSV)
resource
~/ltsv.org
GitHub - BurntSushi/toml: TOML parser for Golang with reflection.
resource
~/github.com
GitHub - gookit/filter: ⏳ Provide filtering, sanitizing, and conversion of Golang data. 提供对Golang数据的过滤，净化，转换。
resource
~/github.com
GitHub - mattn/go-runewidth: wcwidth for golang
resource
~/github.com
Daniil Literate / genmock · GitLab
resource
~/gitlab.com
GitHub - jszwedko/go-circleci: Go library for interacting with CircleCI
resource
~/github.com
GitHub - go-playground/webhooks: :fishing_pole_and_fish: Webhook receiver for GitHub, Bitbucket, GitLab, Gogs
resource
~/github.com
GitHub - golang/mock: GoMock is a mocking framework for the Go programming language.
resource
~/github.com
GitHub - xta/okrun: ok, run your gofile
resource
~/github.com
GitHub - bzick/tokenizer: Tokenizer (lexer) for golang
resource
~/github.com
GitHub - andygrunwald/cachet: Go(lang) client library for Cachet (open source status page system).
resource
~/github.com
GitHub - asticode/go-astitodo: Parse TODOs in your GO code
resource
~/github.com
GitHub - antchfx/htmlquery: htmlquery is golang XPath package for HTML query.
resource
~/github.com
GitHub - pingcap/failpoint: An implementation of failpoints for Golang.
resource
~/github.com
GitHub - go-rod/rod: A Chrome DevTools Protocol driver for web automation and scraping.
resource
~/github.com
#1 Password Manager & Vault App with Single-Sign On & MFA Solutions - LastPass
resource
~/www.lastpass.com
The Best API Documentation Tool
resource
~/redocly.com
Apache Mesos
resource
~/mesos.apache.org
GitHub - microcosm-cc/bluemonday: bluemonday: a fast golang HTML sanitizer (inspired by the OWASP Java HTML Sanitizer) to scrub user generated content of XSS
resource
~/github.com
GitHub - codemodus/kace: Common case conversions covering common initialisms.
resource
~/github.com
GitHub - editorconfig/editorconfig-core-go: EditorConfig Core written in Go
resource
~/github.com
GitHub - adrianmo/go-nmea: A NMEA parser library in pure Go
resource
~/github.com
GitHub - sbstjn/allot: Parse placeholder and wildcard text commands
resource
~/github.com
GitHub - minio/mc: Simple | Fast tool to manage MinIO clusters :cloud:
resource
~/github.com
GitHub - hscells/doi: Parse and check doi objects in go.
resource
~/github.com
GitHub - vektra/mockery: A mock code autogenerator for Go
resource
~/github.com
GitHub - isbm/textwrap: Port of Python's "textwrap" module to Go
resource
~/github.com
JokeAPI
resource
~/sv443.net
GitHub - zpatrick/rclient: Minimalistic REST client for Go applications
resource
~/github.com
gommon/bytes at master · labstack/gommon
resource
~/github.com
GitHub - Kachit/dusupay-sdk-go: Golang SDK for Dusupay payment gateway API (Unofficial)
resource
~/github.com
GitHub - olebedev/when: A natural language date/time parser with pluggable rules
resource
~/github.com
GitHub - mingrammer/commonregex: 🍫 A collection of common regular expressions for Go
resource
~/github.com
GitHub - alxrm/ugo: Simple and expressive toolbox written in Go
resource
~/github.com
GitHub - striker2000/petrovich: Golang port of Petrovich - an inflector for Russian anthroponyms.
resource
~/github.com
GitHub - SpectoLabs/hoverfly: Lightweight service virtualization/ API simulation / API mocking tool for developers and testers
resource
~/github.com
GitHub - clevergo/jsend: :100: JSend's implementation writen in Go(golang)
resource
~/github.com
DeviceCheck | Apple Developer Documentation
resource
~/developer.apple.com
GitHub - shafreeck/retry: A pretty simple library to ensure your work to be done
resource
~/github.com
GitHub - Gituser143/cryptgo: A terminal application to watch crypto prices!
resource
~/github.com
GitLab.org / cli · GitLab
resource
~/gitlab.com
Maxim Lebedev / Telegraph · GitLab
resource
~/gitlab.com
Imgur
resource
~/imgur.com
GitHub - avito-tech/normalize
resource
~/github.com
GitHub - polera/gonameparts: Takes a full name and splits it into individual name parts
resource
~/github.com
GitHub - DATA-DOG/go-txdb: Immutable transaction isolated sql driver for golang
resource
~/github.com
GitHub - matryer/moq: Interface mocking tool for go generate
resource
~/github.com
OpenCage Geocoding API Documentation
resource
~/opencagedata.com
GitHub - posener/ctxutil: utils for Go context
resource
~/github.com
GitHub - GuilhermeCaruso/mooncake: :moon_cake: A simple way to generate mocks for multiple purposes
resource
~/github.com
RFC 4566: SDP: Session Description Protocol
resource
~/tools.ietf.org
The Biggest Video Game Database on RAWG - Video Game Discovery Service
resource
~/rawg.io
GitHub - navidys/gopensky: Go implementation of OpenSKY Network API
resource
~/github.com
GitHub - gojuno/minimock: Powerful mock generation tool for Go programming language
resource
~/github.com
GitHub - bojanz/address: Address handling for Go.
resource
~/github.com
Rob Muhlestein / Unique Identifiers · GitLab
resource
~/gitlab.com
GitHub - codeship/codeship-go: Go library for accessing the Codeship API v2
resource
~/github.com
GitHub - tv42/mockhttp: Mock object for Go http.ResponseWriter
resource
~/github.com
GitHub - cyucelen/walker: Seamlessly fetch paginated data from any source. Simple and high performance API scraping included!
resource
~/github.com
GitHub - pioz/countries: All you need when you are working with countries in Go.
resource
~/github.com
GitHub - bobg/htree: Tools for working with trees of html.Nodes.
resource
~/github.com
GitHub - axelspringer/go-chronos: :dancers: Go Chronos 3.x REST API Client
resource
~/github.com
GitHub - derekparker/delve: Delve is a debugger for the Go programming language.
resource
~/github.com
GitHub - elgohr/go-localstack: Go Wrapper for using localstack
resource
~/github.com
GitHub - cabify/timex: A test-friendly replacement for golang's time package [managed by soy-programador]
resource
~/github.com
GitHub - CalebQ42/bbConvert: Converter from BBCode to HTML
resource
~/github.com
GitHub - bit4bit/gami: GO - Asterisk AMI Interface
resource
~/github.com
GitHub - andy2046/tik: hierarchical timing wheel
resource
~/github.com
GitHub - trubitsyn/go-zero-width: Zero-width character detection and removal for Go
resource
~/github.com
GitHub - vrecan/death: Managing go application shutdown with signals.
resource
~/github.com
GitHub - aerogo/codetree: :evergreen_tree: Parses indented code and returns a tree structure.
resource
~/github.com
GitHub - mmalcek/bafi: Universal JSON, BSON, YAML, CSV, XML, mt940 converter with templates
resource
~/github.com
GitHub - reugn/wifiqr: Create a QR code with your Wi-Fi login details
resource
~/github.com
GitHub - chrispassas/nfdump: NFDump File Reader
resource
~/github.com
GitHub - asticode/go-astisub: Manipulate subtitles in GO (.srt, .ssa/.ass, .stl, .ttml, .vtt (webvtt), teletext, etc.)
resource
~/github.com
GitHub - sostronk/go-steam: Go library for querying Source servers
resource
~/github.com
GitHub - ake-persson/encoding: Go package provides a generic interface to encoders and decoders
resource
~/github.com
GitHub - twharmon/govalid: Struct validation using tags
resource
~/github.com
GitHub - monmohan/xferspdy: Xferspdy provides binary diff and patch library in golang. [Mentioned in Awesome Go, https://github.com/avelino/awesome-go]
resource
~/github.com
GitHub - Henry-Sarabia/sliceconv: Slice conversion between primitive types
resource
~/github.com
GitHub - topfreegames/apm: APM is a process manager for Golang applications.
resource
~/github.com
GitHub - mlimaloureiro/golog: Easy and simple CLI time tracker for your tasks
resource
~/github.com
GitHub - linxGnu/goseaweedfs: A complete Golang client for SeaweedFS
resource
~/github.com
GitHub - Icelain/jokeapi: Official golang wrapper for Sv443's jokeapi.
resource
~/github.com
GitHub - sadlil/go-trigger: A Global event triggerer for golang. Defines functions as event with id string. Trigger the event anywhere from your project.
resource
~/github.com
GitHub - xhd2015/xgo: All-in-one go testing library
resource
~/github.com
GitHub - awalterschulze/gographviz: Parses the Graphviz DOT language in golang
resource
~/github.com
GitHub - JohannesKaufmann/html-to-markdown: ⚙️ Convert HTML to Markdown. Even works with entire websites and can be extended through rules.
resource
~/github.com
GitHub - twharmon/gouid: Fast, dependable universally unique ids
resource
~/github.com
GitHub - sergiotapia/smitego: SmiteGo is an API wrapper for the Smite game from HiRez. It is written in Go!
resource
~/github.com
GitHub - google/gofuzz: Fuzz testing for go.
resource
~/github.com
GitHub - oriser/regroup: Match regex group into go struct using struct tags and automatic parsing
resource
~/github.com
GitHub - mikekonan/go-countries
resource
~/github.com
GitHub - mafredri/cdp: Package cdp provides type-safe bindings for the Chrome DevTools Protocol (CDP), written in the Go programming language.
resource
~/github.com
GitHub - rekby/fastuuid: Fast implementation for uuid
resource
~/github.com
GitHub - rs/xid: xid is a globally unique id generator thought for the web
resource
~/github.com
GitHub - sourcegraph/go-vcs: manipulate and inspect VCS repositories in Go
resource
~/github.com
GitHub - thedevsaddam/govalidator: Validate Golang request data with simple rules. Highly inspired by Laravel's request validation.
resource
~/github.com
GitHub - go-playground/generate: :runner:runs go generate recursively on a specified path or environment variable and can filter by regex
resource
~/github.com
GitHub - lyonnee/hvalid: hvalid is a lightweight validation library written in Go language.(一个用Go语言编写的轻量级验证库)
resource
~/github.com
GitHub - yudppp/throttle: lodash throttle like Go library
resource
~/github.com
GitHub - rapito/go-spotify: Go library for the Spotify Web API
resource
~/github.com
GitHub - zach-klippenstein/goregen: randexp for Go.
resource
~/github.com
GitHub - ngs/go-amazon-product-advertising-api: Go Client Library for Amazon Product Advertising API
resource
~/github.com
GitHub - jonboulle/clockwork: a fake clock for golang
resource
~/github.com
GitHub - aidarkhanov/nanoid: A tiny and fast Go unique string generator
resource
~/github.com
GitHub - Guitarbum722/align: A general purpose application and library for aligning text.
resource
~/github.com
Locations API - Bing Maps
resource
~/msdn.microsoft.com
GitHub - ungerik/go-dry: DRY (don't repeat yourself) package for Go
resource
~/github.com
GitHub - aerokube/ggr: A lightweight load balancer used to create big Selenium clusters
resource
~/github.com
GitHub - google/go-querystring: go-querystring is Go library for encoding structs into URL query strings.
resource
~/github.com
GitHub - esurdam/go-swagger-ui: Golang package which provides http Handlers to serve the swagger ui
resource
~/github.com
GitHub - yaronsumel/filler: fill struct data easily with fill tags
resource
~/github.com
GitHub - Medium/medium-sdk-go: A Golang SDK for Medium's OAuth2 API
resource
~/github.com
GitHub - PumpkinSeed/structs: Golang struct operations.
resource
~/github.com
GitHub - miguelpragier/handy: GO Golang Utilities and helpers like validators and string formatters
resource
~/github.com
GitHub - bndr/gopencils: Easily consume REST APIs with Go (golang)
resource
~/github.com
GitHub - chonthu/go-google-analytics: Simple Reporting for Google Analytics
resource
~/github.com
GitHub - ulule/deepcopier: simple struct copying for golang
resource
~/github.com
GitHub - mvdan/xurls: Extract urls from text
resource
~/github.com
GitHub - utekaravinash/gopaapi5: Go Client Library for Amazon's Product Advertising API 5.0
resource
~/github.com
GitHub - IGLOU-EU/go-wildcard: 🚀 Fast and light wildcard pattern matching.
resource
~/github.com
GitHub - michiwend/goplaceholder: a small golang lib to generate placeholder images
resource
~/github.com
GitHub - yourbasic/radix: A fast string sorting algorithm (MSD radix sort)
resource
~/github.com
GitHub - Omie/rrdaclient: Go bindings for RRDA https://github.com/fcambus/rrda
resource
~/github.com
GitHub - staskobzar/goami2: Simple Asterisk Manager Interface (AMI) library fo golang
resource
~/github.com
GitHub - antham/chyle: Changelog generator : use a git repository and various data sources and publish the result on external services
resource
~/github.com
GitHub - jarcoal/httpmock: HTTP mocking for Golang
resource
~/github.com
GitHub - maxbrunsfeld/counterfeiter: A tool for generating self-contained, type-safe test doubles in go
resource
~/github.com
GitHub - emiddleton/gads: Google Adwords API for Go
resource
~/github.com
GitHub - andybons/hipchat: This project implements a Go client library for the Hipchat API.
resource
~/github.com
GitHub - JoshuaDoes/gofuckyourself: A sanitization-based swear filter for Go.
resource
~/github.com
GitHub - gobuffalo/validate: This package provides a framework for writing validations for Go applications.
resource
~/github.com
GitHub - owenthereal/upterm: Instant Terminal Sharing
resource
~/github.com
GitHub - mvdan/sh: A shell parser, formatter, and interpreter with bash support; includes shfmt
resource
~/github.com
GitHub - adelowo/onecache: One caching API, Multiple backends
resource
~/github.com
GitHub - osamingo/checkdigit: Provide check digit algorithms and calculators written in Go
resource
~/github.com
GitHub - subosito/gotenv: Load environment variables from `.env` or `io.Reader` in Go.
resource
~/github.com
GitHub - ansd/lastpass-go: Golang client for LastPass
resource
~/github.com
GitHub - guiferpa/gody: :balloon: A lightweight struct validator for Go
resource
~/github.com
GitHub - icza/backscanner: A scanner similar to bufio.Scanner, but it reads and returns lines in reverse order, starting at a given position and going backward.
resource
~/github.com
GitHub - codemodus/parth
resource
~/github.com
GitHub - jellydator/newsapi-go: Go client for NewsAPI
resource
~/github.com
GitHub - rapito/go-shopify: Simple Shopify API for the Go Programming Language
resource
~/github.com
GitHub - etherlabsio/go-m3u8: Parse and generate m3u8 playlists for Apple HTTP Live Streaming (HLS) in Golang (ported from gem https://github.com/sethdeckard/m3u8)
resource
~/github.com
GitHub - edwingeng/wuid: An extremely fast globally unique number generator.
resource
~/github.com
GitHub - inancgumus/myhttp: Simplest HTTP GET requester for Go with timeout support
resource
~/github.com
GitHub - txgruppi/command: Command pattern for Go with thread safe serial and parallel dispatcher
resource
~/github.com
GitHub - kamilsk/retry: ♻️ The most advanced interruptible mechanism to perform actions repetitively until successful.
resource
~/github.com
GitHub - n0madic/google-play-scraper: Golang scraper to get data from Google Play Store
resource
~/github.com
GitHub - hedhyw/rex: Flexible regular expressions constructor for Golang.
resource
~/github.com
GitHub - ztrue/shutdown: Golang app shutdown hooks.
resource
~/github.com
GitHub - janiltonmaciel/statiks: Fast, zero-configuration, static HTTP filer server.
resource
~/github.com
GitHub - andrewstuart/goq: A declarative struct-tag-based HTML unmarshaling or scraping package for Go built on top of the goquery library
resource
~/github.com
GitHub - coinpaprika/coinpaprika-api-go-client: Go client library for interacting with Coinpaprika's API
resource
~/github.com
GitHub - VividCortex/robustly: Run functions resiliently in Go, catching and restarting panics
resource
~/github.com
GitHub - rafaeljesus/retry-go: Retrying made simple and easy for golang
resource
~/github.com
GitHub - mvrilo/go-redoc: go-redoc is an embedded OpenAPI/Swagger documentation ui for Go using ReDoc
resource
~/github.com
GitHub - sinhashubham95/bleep: OS Signal Handlers in Go
resource
~/github.com
GitHub - ip2location/ip2location-io-go: IP2Location.io Go SDK allows user to query for an enriched data set based on IP address and provides WHOIS lookup api that helps users to obtain domain information.
resource
~/github.com
GitHub - MonaxGT/gomalshare: Go library MalShare API
resource
~/github.com
GitHub - 3d0c/gmf: Go Media Framework
resource
~/github.com
GitHub - clbanning/mxj: Decode / encode XML to/from map[string]interface{} (or JSON); extract values with dot-notation paths and wildcards. Replaces x2j and j2x packages.
resource
~/github.com
GitHub - fastschema/fastschema: A Go web framework and Headless CMS
resource
~/github.com
GitHub - alecthomas/go_serialization_benchmarks: Benchmarks of Go serialization methods
resource
~/github.com
opennota / re2dfa · GitLab
resource
~/gitlab.com
Go - IntelliJ IDEs Plugin | Marketplace
resource
~/plugins.jetbrains.com
GitHub - abemedia/go-don: API framework written in Golang.
resource
~/github.com
GitHub - InVisionApp/rye: A tiny http middleware for Golang with added handlers for common needs.
resource
~/github.com
GitHub - rs/formjson: Go net/http handler to transparently manage posted JSON
resource
~/github.com
GitHub - twharmon/golamb: Use Go for AWS Lambda & API Gateway HttpApi
resource
~/github.com
GitHub - shubhamzanwar/design-patterns: common creational, behavioural and structural patterns implemented in go 🤩
resource
~/github.com
GitHub - ChrisMcKenzie/dropship: Super simple deployment tool
resource
~/github.com
GitHub - nbari/violetear: Go HTTP router
resource
~/github.com
GitHub - beego/beego: beego is an open-source, high-performance web framework for the Go programming language.
resource
~/github.com
GitHub - urfave/negroni: Idiomatic HTTP Middleware for Golang
resource
~/github.com
GitHub - goji/goji: Goji is a minimalistic and flexible HTTP request multiplexer for Go (golang)
resource
~/github.com
GitHub - gin-gonic/gin: Gin is a HTTP web framework written in Go (Golang). It features a Martini-like API with much better performance -- up to 40 times faster. If you need smashing performance, get yourself some Gin.
resource
~/github.com
GitHub - kelseyhightower/confd: Manage local application configuration files using templates and data from etcd or consul
resource
~/github.com
GitHub - gotuna/gotuna: GoTuna a lightweight web framework for Go with mux router, middlewares, user sessions, templates, embedded views, and static file server.
resource
~/github.com
Fruitygo / Pnutmux · GitLab
resource
~/gitlab.com
GitHub - go-zoo/bone: Lightning Fast HTTP Multiplexer
resource
~/github.com
GitHub - codemodus/chain: Composable chains of nested http.Handler instances.
resource
~/github.com
GitHub - ungerik/go-rest: A small and evil REST framework for Go
resource
~/github.com
GitHub - i-love-flamingo/flamingo-commerce: Flexible E-Commerce Framework on top of Flamingo. Used to build E-Commerce "Portals" and connect it with the help of individual Adapters to other services.
resource
~/github.com
GitHub - bnkamalesh/webgo: A microframework to build web apps; with handler chaining, middleware support, and most of all; standard library compliant HTTP handlers(i.e. http.HandlerFunc).
resource
~/github.com
GitHub - xxjwxc/ginrpc: gin auto binding,grpc, and annotated route,gin 注解路由, grpc,自动参数绑定工具
resource
~/github.com
GitHub - smallnest/go-web-framework-benchmark: :zap: Go web framework benchmark
resource
~/github.com
GitHub - markfarnan/go-canvas: Library to use HTML5 Canvas from Go-WASM, with all drawing within go code
resource
~/github.com
GitHub - vardius/gorouter: Go Server/API micro framework, HTTP request router, multiplexer, mux
resource
~/github.com
GitHub - razonyang/fastrouter: FastRouter is a fast, flexible HTTP router written in Go.
resource
~/github.com
GitHub - revel/revel: A high productivity, full-stack web framework for the Go language.
resource
~/github.com
GitHub - ulule/limiter: Dead simple rate limit middleware for Go.
resource
~/github.com
GitHub - gogf/gf: GoFrame is a modular, powerful, high-performance and enterprise-class application development framework of Golang.
resource
~/github.com
GitHub - stephens2424/muxchain: Lightweight Middleware for net/http
resource
~/github.com
GitHub - gernest/alien: A lightweight and fast http router from outer space
resource
~/github.com
GitHub - labstack/echo: High performance, minimalist Go web framework
resource
~/github.com
Welcome to aah Go web framework
resource
~/aahframework.org
GitHub - gorilla/mux: Package gorilla/mux is a powerful HTTP router and URL matcher for building Go web servers with 🦍
resource
~/github.com
GitHub - gofr-dev/gofr: An opinionated GoLang framework for accelerated microservice development. Built in support for databases and observability.
resource
~/github.com
GitHub - oxyno-zeta/s3-proxy: S3 Reverse Proxy with GET, PUT and DELETE methods and authentication (OpenID Connect and Basic Auth)
resource
~/github.com
GitHub - philips-labs/spiffe-vault: Integrates Spiffe and Vault to have secretless authentication
resource
~/github.com
GitHub - aisk/vox: Simple and lightweight Go web framework inspired by koa
resource
~/github.com
Jeffrey D. / blanket · GitLab
resource
~/gitlab.com
GitHub - bmf-san/goblin: A golang http router based on trie tree.
resource
~/github.com
GitHub - go-macaron/macaron: Package macaron is a high productive and modular web framework in Go.
resource
~/github.com
Go Profiling - Visual Studio Marketplace
resource
~/marketplace.visualstudio.com
GitHub - dennwc/dom: DOM library for Go and WASM
resource
~/github.com
GitHub - julienschmidt/httprouter: A high performance HTTP request router that scales well
resource
~/github.com
GitHub - yarf-framework/yarf: Yet Another REST Framework
resource
~/github.com
GitHub - tinygo-org/tinygo: Go compiler for small places. Microcontrollers, WebAssembly (WASM/WASI), and command-line tools. Based on LLVM.
resource
~/github.com
GitHub - rs/xmux: xmux is a httprouter fork on top of xhandler (net/context aware)
resource
~/github.com
GitHub - gofiber/fiber: ⚡️ Express inspired web framework written in Go
resource
~/github.com
GitHub - claygod/microservice: This library provides a simple microservice framework based on clean architecture principles with a working example implemented.
resource
~/github.com
GitHub - rainycape/gondola: The web framework for writing faster sites, faster
resource
~/github.com
GitHub - golobby/router: A lightweight yet powerful HTTP router for the Go programming language
resource
~/github.com
GitHub - bobg/mid: Middleware for HTTP services in Go
resource
~/github.com
GitHub - husobee/vestigo: Echo Inspired Stand Alone URL Router
resource
~/github.com
GitHub - thoas/stats: A Go middleware that stores various information about your web application (response time, status code count, etc.)
resource
~/github.com
GitHub - didip/tollbooth: Simple middleware to rate-limit HTTP requests.
resource
~/github.com
GitHub - justinas/alice: Painless middleware chaining for Go
resource
~/github.com
GitHub - i-love-flamingo/flamingo: Flamingo Framework and Core Library. Flamingo is a go based framework to build pluggable applications. Focus is on clean architecture, maintainability and operation readiness.
resource
~/github.com
GitHub - danielgtaylor/huma: Huma REST/HTTP API Framework for Golang with OpenAPI 3.1
resource
~/github.com
The world’s fastest framework for building websites
resource
~/gohugo.io
GitHub - shalakhin/gophericons: 34 gopher images for Go developers community
resource
~/github.com
GopherCon Israel 2024
resource
~/www.gophercon.org.il
GitHub - nytimes/gizmo: A Microservice Toolkit from The New York Times
resource
~/github.com
GitHub - nikolaydubina/go-ml-benchmarks: ⏱ Benchmarks of machine learning inference for Go
resource
~/github.com
GitHub - ankorstore/yokai: Simple, modular, and observable Go framework for backend applications.
resource
~/github.com
Let’s Go Further!
resource
~/lets-go-further.alexedwards.net
GitHub - mibk/dupl: a tool for code clone detection
resource
~/github.com
GitHub - agnivade/wasmbrowsertest: Run WASM tests inside your browser
resource
~/github.com
GitHub - sebest/xff: A Golang Middleware to handle X-Forwarded-For Header
resource
~/github.com
GitHub - resoursea/api: A REST framework for quickly writing resource based services in Golang.
resource
~/github.com
GitHub - go-goyave/goyave: 🍐 The enterprise REST API framework
resource
~/github.com
GitHub - aerogo/aero: :bullettrain_side: High-performance web server for Go (2016). New alpha (2024) with even better performance is currently in development at https://git.akyoto.dev/go/web
resource
~/github.com
GitHub - bnkamalesh/goapp: An opinionated guideline to structure & develop a Go web application/service
resource
~/github.com
GitHub - ngamux/ngamux: Simple HTTP router for Go
resource
~/github.com
Gophers Japan
resource
~/gocon.connpass.com
GitHub - hidevopsio/hiboot: hiboot is a high performance web and cli application framework with dependency injection support
resource
~/github.com
GitHub - xitonix/trubka: A CLI tool for Kafka
resource
~/github.com
GitHub - wellington/wellington: Spriting that sass has been missing
resource
~/github.com
GitHub - kazhuravlev/options-gen: Codegen for functional options in go projects
resource
~/github.com
GitHub - twharmon/goweb: Lightweight web framework based on net/http.
resource
~/github.com
GitHub - beatlabs/patron: Microservice framework following best cloud practices with a focus on productivity.
resource
~/github.com
GitHub - timdp/lwc: A live-updating version of the UNIX wc command.
resource
~/github.com
GitHub - grafana/k6: A modern load testing tool, using Go and JavaScript - https://k6.io
resource
~/github.com
GitHub - go-the-way/anoweb: The lightweight and powerful web framework using the new way for Go.Another go the way.
resource
~/github.com
GitHub - faabiosr/echo-middleware: Go package that provides multiple middlewares for Echo Framework.
resource
~/github.com
go-tools/cmd/staticcheck at master · dominikh/go-tools
resource
~/github.com
GitHub - goadesign/goa: 🌟 Goa: Elevate Go API development! 🚀 Streamlined design, automatic code generation, and seamless HTTP/gRPC support. ✨
resource
~/github.com
GitHub - kubenetworks/kubevpn: KubeVPN offers a Cloud Native Dev Environment that connects to kubernetes cluster network. Gain access to k8s cluster network using service names or Pod IP/Service IP. Intercept k8s cluster service inbound traffic to local PC through a service mesh. Run your k8s pod within a local Docker container with identical env、volume and network setup.
resource
~/github.com
GitHub - cryptojuice/gobrew: Shell script to download and set GO environmental paths to allow multiple versions.
resource
~/github.com
GitHub - extism/go-sdk: Extism Go SDK
resource
~/github.com
GitHub - thedevsaddam/renderer: Simple, lightweight and faster response (JSON, JSONP, XML, YAML, HTML, File) rendering package for Go
resource
~/github.com
GitHub - muir/nchi: golang http router with elegance, speed, and flexibility
resource
~/github.com
GitHub - rogerwelin/cassowary: :rocket: Modern cross-platform HTTP load-testing tool written in Go
resource
~/github.com
GitHub - goa-go/goa: Goa is a web framework based on middleware, like koa.js.
resource
~/github.com
GitHub - gookit/rux: ⚡ Rux is an simple and fast web framework. support route group, param route binding, middleware, compatible http.Handler interface. 简单且快速的 Go api/web 框架，支持路由分组，路由参数绑定，中间件，兼容 http.Handler 接口
resource
~/github.com
GitHub - xujiajun/gorouter: xujiajun/gorouter is a simple and fast HTTP router for Go. It is easy to build RESTful APIs and your web framework.
resource
~/github.com
Go Faster
resource
~/leanpub.com
GitHub - dinever/golf: :golf: The Golf web framework
resource
~/github.com
GitHub - go-chi/chi: lightweight, idiomatic and composable router for building Go HTTP services
resource
~/github.com
GitHub - gulien/orbit: :satellite: A cross-platform task runner for executing commands and generating files from templates
resource
~/github.com
gitea-github-migrator
resource
~/git.jonasfranz.software
GitHub - philippgille/ln-paywall: Go middleware for monetizing your API on a per-request basis with Bitcoin and Lightning ⚡️
resource
~/github.com
GitHub - mitchellh/go-server-timing: Go (golang) library for creating and consuming HTTP Server-Timing headers
resource
~/github.com
GitHub - uadmin/uadmin: The web framework for Golang
resource
~/github.com
GitHub - stefanprodan/podinfo: Go microservice template for Kubernetes
resource
~/github.com
GopherCon Europe 2024
resource
~/gophercon.eu
GitHub - feyeleanor/gospeed: Go micro-benchmarks for calculating the speed of language constructs
resource
~/github.com
GitHub - gernest/utron: A lightweight MVC framework for Go(Golang)
resource
~/github.com
GitHub - codemodus/catena: gRPC interceptor catenation.
resource
~/github.com
GitHub - posener/client-timing: An HTTP client for go-server-timing middleware. Enables automatic timing propagation through HTTP calls between servers.
resource
~/github.com
GitHub - appleboy/drone-scp: Copy files and artifacts via SSH using a binary, docker or Drone CI.
resource
~/github.com
GitHub - kool-dev/kool: From local development to the cloud: web apps development with containers made easy.
resource
~/github.com
GitHub - cloudwego/hertz: Go HTTP framework with high-performance and strong-extensibility for building micro-services.
resource
~/github.com
Let’s Go! Learn to build web apps with Go
resource
~/lets-go.alexedwards.net
GitHub - tsenart/vegeta: HTTP load testing tool and library. It's over 9000!
resource
~/github.com
GitHub - goroute/route: Go Route - Simple yet powerful HTTP request multiplexer
resource
~/github.com
GitHub - GuilhermeCaruso/bellt: :bell: A simple Go router
resource
~/github.com
GitHub - ivpusic/neo: Go Web Framework
resource
~/github.com
Go With The Domain
resource
~/threedots.tech
GitHub - go-fuego/fuego: Golang Fuego - web framework generating OpenAPI 3 spec from source code
resource
~/github.com
GitHub - norunners/vert: WebAssembly interop between Go and JS values.
resource
~/github.com
GitHub - VividCortex/siesta: Composable framework for writing HTTP handlers in Go.
resource
~/github.com
GitHub - claygod/Bxog: Bxog is a simple and fast HTTP router for Go (HTTP request multiplexer).
resource
~/github.com
GitHub - bayandin/awesome-awesomeness: A curated list of awesome awesomeness
resource
~/github.com
GitHub - go-playground/pure: :non-potable_water: Is a lightweight HTTP router that sticks to the std "net/http" implementation
resource
~/github.com
GitHub - HereMobilityDevelopers/mediary: Add interceptors to GO http.Client
resource
~/github.com
GitHub - gowebapi/webapi: Go Lang Web Assembly bindings for DOM, HTML etc
resource
~/github.com
Go in Practice, Second Edition
resource
~/www.manning.com
Golang Bangalore | Meetup
resource
~/www.meetup.com
Golang Amsterdam | Meetup
resource
~/www.meetup.com
tools/gopls/README.md at master · golang/tools
resource
~/github.com
GitHub - peak/s5cmd: Parallel S3 and local filesystem execution tool.
resource
~/github.com
Golang DC | Meetup
resource
~/www.meetup.com
GoLab | The International Conference on Go in Florence
resource
~/golab.io
Golang Argentina | Meetup
resource
~/www.meetup.com
Utah Go User Group | Meetup
resource
~/www.meetup.com
404 Page Not Found - codewithmukesh
resource
~/codewithmukesh.com
Go Stockholm | Meetup
resource
~/www.meetup.com
GitHub - fulldump/golax: Golax, a go implementation for the Lax framework.
resource
~/github.com
Awesome Go | LibHunt
resource
~/go.libhunt.com
GitHub - tejo/boxed: dropbox based blog engine, written in go.
resource
~/github.com
GitHub - lunny/tango: This is only a mirror and Moved to https://gitea.com/lunny/tango
resource
~/github.com
Golang Dorset | Meetup
resource
~/www.meetup.com
Atlanta Go User Group | Meetup
resource
~/www.meetup.com
London Gophers | Meetup
resource
~/www.meetup.com
Athens Gophers | Meetup
resource
~/www.meetup.com
Golang Estonia | Meetup
resource
~/www.meetup.com
Belfast Gophers | Meetup
resource
~/www.meetup.com
Go Cph | Meetup
resource
~/www.meetup.com
Basel Go Meetup | Meetup
resource
~/www.meetup.com
Golang Rotterdam | Meetup
resource
~/www.meetup.com
Boston Golang | Meetup
resource
~/www.meetup.com
golang-syd | Meetup
resource
~/www.meetup.com
Ukrainian Golang User Groups | Meetup
resource
~/www.meetup.com
GitHub - goanywhere/rex: Pleasures for Web in Golang
resource
~/github.com
GitHub - unrolled/render: Go package for easily rendering JSON, XML, binary data, and HTML templates responses.
resource
~/github.com
GitHub - jvcoutinho/lit: A simple, fast and expressive HTTP framework for Go.
resource
~/github.com
GitHub - aofei/air: An ideally refined web framework for Go.
resource
~/github.com
Bärner Go Meetup | Meetup
resource
~/www.meetup.com
GitHub - buaazp/fasthttprouter: A high performance fasthttp request router that scales well
resource
~/github.com
Cardiff Go Meetup | Meetup
resource
~/www.meetup.com
Golang Kathmandu | Meetup
resource
~/www.meetup.com
GitHub - rs/cors: Go net/http configurable handler to handle CORS requests
resource
~/github.com
GoJakarta | Meetup
resource
~/www.meetup.com
GopherCon Russia 2021
resource
~/www.gophercon-russia.ru
Golang Aix Marseille | Meetup
resource
~/www.meetup.com
GoSG | Meetup
resource
~/www.meetup.com
GitHub - sbabiv/xml2map: XML to MAP converter written Golang
resource
~/github.com
GO Belo Horizonte | Meetup
resource
~/www.meetup.com
GitHub - go-ole/go-ole: win32 ole implementation for golang
resource
~/github.com
Golang Serbia | Meetup
resource
~/www.meetup.com
GitHub - savsgio/atreugo: High performance and extensible micro web framework. Zero memory allocations in hot paths.
resource
~/github.com
Brisbane Gophers | Meetup
resource
~/www.meetup.com
GitHub - kubernetes/kubernetes: Production-Grade Container Scheduling and Management
resource
~/github.com
GitHub - MonaxGT/gosddl: GoSDDL converter
resource
~/github.com
GitHub - SimonWaldherr/golang-benchmarks: Go(lang) benchmarks - (measure the speed of golang)
resource
~/github.com
GitHub - gowww/router: ⚡️ A lightning fast HTTP router
resource
~/github.com
GitHub - gopulse/pulse: Pulse: A Golang framework for web development
resource
~/github.com
Istanbul Golang | Meetup
resource
~/www.meetup.com
Golang Bulgaria | Meetup
resource
~/www.meetup.com
GitHub - mk-5/fjira: The golang fuzzy-find cli jira interface 🚀
resource
~/github.com
Golang Москва | Meetup
resource
~/www.meetup.com
GolangCWB | Meetup
resource
~/www.meetup.com
Golang SP | Meetup
resource
~/www.meetup.com
GoBandung | Meetup
resource
~/www.meetup.com
GitHub - paulbellamy/mango: Mango is a modular web-application framework for Go, inspired by Rack, and PEP333.
resource
~/github.com
Gurgaon Go Meetup | Meetup
resource
~/www.meetup.com
GDG Go & Cloud User Group Hamburg | Meetup
resource
~/www.meetup.com
Zürich Gophers | Meetup
resource
~/www.meetup.com
Go Remote Meetup | Meetup
resource
~/www.meetup.com
Golang Melbourne | Meetup
resource
~/www.meetup.com
GitHub - go-swagger/go-swagger: Swagger 2.0 implementation for go
resource
~/github.com
vienna.go (Golang) | Meetup
resource
~/www.meetup.com
Golang Taipei | Meetup
resource
~/www.meetup.com
GolangVan | Meetup
resource
~/www.meetup.com
GitHub - bradleyfalzon/apicompat: apicompat checks recent changes to a Go project for backwards incompatible changes
resource
~/github.com
GitHub - arxdsilva/golang-ifood-sdk: Golang Ifood API SDK
resource
~/github.com
GitHub - kisielk/errcheck: errcheck checks that you checked errors.
resource
~/github.com
GitHub - roblaszczak/go-cleanarch: Clean architecture validator for go, like a The Dependency Rule and interaction between packages in your Go projects.
resource
~/github.com
GOSAMPLES: Go (Golang) Tutorials & Examples | gosamples.dev
resource
~/gosamples.dev
GoCracow | Meetup
resource
~/www.meetup.com
Women Who Go | Meetup
resource
~/www.meetup.com
GitHub - msyrus/vscode-go-doc: An Microsoft Visual Code extension for Golang to print symbol definition to output
resource
~/github.com
GitHub - davecheney/gcvis: Visualise Go program GC trace data in real time
resource
~/github.com
GitHub - shabbyrobe/xmlwriter: xmlwriter is a pure-Go library providing procedural XML generation based on libxml2's xmlwriter module
resource
~/github.com
Go TO | Meetup
resource
~/www.meetup.com
Thanos
resource
~/thanos.io
Golang Lyon | Meetup
resource
~/www.meetup.com
GitHub - mustafaakin/gongular: A different approach to Go web frameworks
resource
~/github.com
GitHub - dimfeld/httptreemux: High-speed, flexible tree-based HTTP router for Go.
resource
~/github.com
Sourcegraph docs
resource
~/docs.sourcegraph.com
Go Forum
resource
~/forum.golangbridge.org
GitHub - yuroyoro/goast-viewer: Golang AST visualizer
resource
~/github.com
GitHub - Checkmarx/chainjacking: Find which of your direct GitHub dependencies is susceptible to RepoJacking attacks
resource
~/github.com
Gophercises
resource
~/gophercises.com
GitHub - go-playground/lars: :rotating_light: Is a lightweight, fast and extensible zero allocation HTTP router for Go used to create customizable frameworks.
resource
~/github.com
GitHub - go-ozzo/ozzo-routing: An extremely fast Go (golang) HTTP router that supports regular expression route matching. Comes with full support for building RESTful APIs.
resource
~/github.com
GitHub - gocraft/web: Go Router + Middleware. Your Contexts.
resource
~/github.com
Go Tutorial
resource
~/www.tutorialspoint.com
Golang Pune | Meetup
resource
~/www.meetup.com
GitHub - mccoyst/validate: A Go package to automatically validate fields with tags
resource
~/github.com
Docker: Accelerated Container Application Development
resource
~/www.docker.com
Golang tutorial series
resource
~/golangbot.com
Golang North East | Meetup
resource
~/www.meetup.com
Baltimore Metro Area Go User Group | Meetup
resource
~/www.meetup.com
GitHub - rookie-ninja/rk-boot: Build microservice with rk-boot and let the team take over clean and tidy code.
resource
~/github.com
GopherCon 2024 - Register Now
resource
~/www.gophercon.com
Seattle Go Programmers | Meetup
resource
~/www.meetup.com
GitHub - mgechev/revive: 🔥 ~6x faster, stricter, configurable, extensible, and beautiful drop-in replacement for golint
resource
~/github.com
TOML-to-Go
resource
~/xuri.me
GitHub - antchfx/xpath: XPath package for Golang, supports HTML, XML, JSON document query.
resource
~/github.com
Golang Paris | Meetup
resource
~/www.meetup.com
GitHub - mdempsky/unconvert: Remove unnecessary type conversions from Go source
resource
~/github.com
GolangLima | Meetup
resource
~/www.meetup.com
GitHub - XML-Comp/XML-Comp: Compare ANY markup documents.
resource
~/github.com
Lagos Gophers | Meetup
resource
~/www.meetup.com
GitHub - gonutz/d3d9: Direct3D9 wrapper for Go.
resource
~/github.com
GDG Berlin Golang | Meetup
resource
~/www.meetup.com
Golang Tutorial Guide – A List of Free Courses to Learn the Go Programming Language
resource
~/www.freecodecamp.org
GitHub - amit-davidson/Chronos: Chronos - A static race detector for the go language
resource
~/github.com
GolangNYC | Meetup
resource
~/www.meetup.com
Go Israel | Meetup
resource
~/www.meetup.com
GitHub - rcrowley/go-tigertonic: A Go framework for building JSON web services inspired by Dropwizard
resource
~/github.com
Thessaloniki Gophers Meetup | Meetup
resource
~/www.meetup.com
GitHub - firstrow/go-outdated: Find outdated golang packages
resource
~/github.com
GoBridge | Meetup
resource
~/www.meetup.com
GitHub - augmentable-dev/tickgit: Manage your repository's TODOs, tickets and checklists as config in your codebase.
resource
~/github.com
GitHub - gone-io/gone: Gone is a lightweight golang dependency injection framework; a series of Goners components are built in for rapid development of micro services.
resource
~/github.com
Go WebAssembly Tutorial - Building a Calculator Tutorial
resource
~/tutorialedge.net
GitHub - shurcooL/gostatus: A command line tool that shows the status of Go repositories.
resource
~/github.com
GitHub - sashamelentyev/usestdlibvars: A linter that detect the possibility to use variables/constants from the Go standard library.
resource
~/github.com
GitHub - appist/appy: An opinionated productive web framework that helps scaling business easier.
resource
~/github.com
GitHub - antchfx/xquery: Extract data or evaluate value from HTML/XML documents using XPath
resource
~/github.com
GitHub - qiniu/checkstyle: checkstyle for go
resource
~/github.com
GitHub - in-toto/in-toto-golang: A Go implementation of in-toto. in-toto is a framework to protect software supply chain integrity.
resource
~/github.com
GitHub - asty-org/asty: Converts golang AST to JSON and JSON to AST
resource
~/github.com
Learn Go - Best Go Tutorials | Hackr.io
resource
~/hackr.io
Golang for E-Commerce: Intro, Tools & Live Demo
resource
~/snipcart.com
GitHub - surullabs/lint: Run linters from Go code -
resource
~/github.com
GitHub - hexdigest/gounit-vim: Vim plugin for https://github.com/hexdigest/gounit
resource
~/github.com
GitHub - rjohnsondev/vim-compiler-go: Vim compiler plugin for Go (golang)
resource
~/github.com
GitHub - josa42/coc-go: Go language server extension using gopls for coc.nvim.
resource
~/github.com
GitHub - theia-ide/go-language-server: A Go language server.
resource
~/github.com
100 Go Mistakes and How to Avoid Them
resource
~/www.manning.com
GitHub - nsf/gocode: An autocompletion daemon for the Go programming language
resource
~/github.com
GitHub - tenntenn/gopher-stickers: gopher stickers
resource
~/github.com
GitHub - cheekybits/genny: Elegant generics for Go
resource
~/github.com
GitHub - preslavmihaylov/todocheck: A static code analyser for annotated TODO comments
resource
~/github.com
Golang
resource
~/tutorialedge.net
Go by Example
resource
~/www.manning.com
GitHub - spiffe/spire: The SPIFFE Runtime Environment
resource
~/github.com
GitHub - songgao/colorgo: Colorize (highlight) `go build` command output
resource
~/github.com
Golang Jobs - OnSite and Remote Golang Jobs - August 2022
resource
~/golangjob.xyz
GitHub - sillecelik/go-gopher: The Go Gopher Amigurumi Pattern
resource
~/github.com
GoLand by JetBrains: More than just a Go IDE
resource
~/jetbrains.com
GitHub - janosdebugs/go-patterns
resource
~/github.com
Shipping Go
resource
~/www.manning.com
GitHub - Sioro-Neoku/go-peerflix: Go Peerflix
resource
~/github.com
GitHub - g4s8/envdoc: Go tool to generate documentation for environment variables
resource
~/github.com
GitHub - MariaLetta/free-gophers-pack: ✨ This pack of 100+ gopher pictures and elements will help you to build own design of almost anything related to Go Programming Language: presentations, posts in blogs or social media, courses, videos and many, many more.
resource
~/github.com
GitHub - ant0ine/go-json-rest: A quick and easy way to setup a RESTful JSON API
resource
~/github.com
GitHub - rookie-ninja/rk-grpc: Start gRPC microservice from YAML, plugin of rk-boot
resource
~/github.com
Understanding Go in sketchnotes Series' Articles
resource
~/dev.to
GitHub - jfeliu007/goplantuml: PlantUML Class Diagram Generator for golang projects
resource
~/github.com
GitHub - eaburns/Watch: Watches for changes in a directory tree and reruns a command in an acme win or just on the terminal.
resource
~/github.com
GitHub - hexdigest/gounit: Unit tests generator for Go programming language
resource
~/github.com
GitHub - mafulong/godal: godal provides the ability to generate specific golang code. The godal is to enable developers to write fast code in an expressive way.
resource
~/github.com
Scaling Go Applications | Better Stack Community
resource
~/betterstack.com
GitHub - rogeralsing/gophers: random gopher graphics
resource
~/github.com
GitHub - psampaz/go-mod-outdated: Find outdated dependencies of your Go projects. go-mod-outdated provides a table view of the go list -u -m -json all command which lists all dependencies of a Go project and their available minor and patch updates. It also provides a way to filter indirect dependencies and dependencies without updates.
resource
~/github.com
GitHub - tylertreat/comcast: Simulating shitty network connections so you can build better systems.
resource
~/github.com
GitHub - theia-ide/theia-go-extension: Theia Go Extension
resource
~/github.com
#go on Hashnode
resource
~/hashnode.com
GitHub - usk81/generic: flexible data type for Go
resource
~/github.com
GitHub - ninedraft/gocryforhelp: List of opensource projects looking for help
resource
~/github.com
GitHub - GolangUA/gopher-logos: adorable gopher logos
resource
~/github.com
GitHub - tylerwince/godbg: Go implementation of the Rust `dbg` macro
resource
~/github.com
GitHub - visualfc/liteide: LiteIDE is a simple, open source, cross-platform Go IDE.
resource
~/github.com
GitHub - go-critic/go-critic: The most opinionated Go source code linter for code audit.
resource
~/github.com
GitHub - joefitzgerald/go-plus: An Enhanced Go Experience For The Atom Editor
resource
~/github.com
Build an Orchestrator in Go (From Scratch)
resource
~/www.manning.com
GitHub - segmentio/golines: A golang formatter that fixes long lines
resource
~/github.com
GitHub - rookie-ninja/rk-gin: Start gin microservice from YAML, plugin of rk-boot
resource
~/github.com
GitHub - fatih/vim-go: Go development plugin for Vim
resource
~/github.com
GitHub - thewhitetulip/web-dev-golang-anti-textbook: Learn how to write webapps without a framework in Go.
resource
~/github.com
GitHub - carbocation/interpose: Minimalist net/http middleware for golang
resource
~/github.com
GitHub - bouk/gonerics: Generics for go
resource
~/github.com
GitHub - z7zmey/php-parser: PHP parser written in Go
resource
~/github.com
How to Use Godog for Behavior-driven Development in Go - Semaphore
resource
~/semaphoreci.com
GitHub - cuongndc/7_days_of_go: Learn everything about Go in 7 days (from a Nodejs developer).
resource
~/github.com
GoDays 2020 in Berlin - Connect with hundreds of like-minded people
resource
~/www.godays.io
GitHub - dominikh/go-mode.el: Emacs mode for the Go programming language
resource
~/github.com
GitHub - miku/zek: Generate a Go struct from XML.
resource
~/github.com
Go go-to guide
resource
~/yourbasic.org
GitHub - keygx/Go-gopher-Vector: Go gopher Vector Data [.ai, .svg]
resource
~/github.com
GitHub - golang/vscode-go: Go extension for Visual Studio Code
resource
~/github.com
GitHub - jimrobinson/kvbench: Key/Value database benchmark
resource
~/github.com
The Open Operator Collection
resource
~/jujucharms.com
GitHub - matryer/gopherize.me: Gopherize.me app
resource
~/github.com
GitHub - tyler-smith/golang-sql-benchmark: A benchmarking shootout of various db/SQL utilities for Go
resource
~/github.com
GitHub - Jeffail/leaps: A pair programming service using operational transforms
resource
~/github.com
GitHub - alajmo/sake: :robot: sake is a task runner for local and remote hosts
resource
~/github.com
GitHub - s0rg/crawley: The unix-way web crawler
resource
~/github.com
GitHub - shurcooL/Go-Package-Store: An app that displays updates for the Go packages in your GOPATH.
resource
~/github.com
GitHub - rs/rest-layer: REST Layer, Go (golang) REST API framework
resource
~/github.com
GitHub - cweill/gotests: Automatically generate Go test boilerplate from your source code.
resource
~/github.com
GitHub - ok-borg/borg: Search and save shell snippets without leaving your terminal
resource
~/github.com
GitHub - mkaz/working-with-go: A set of example golang code to start learning Go
resource
~/github.com
GitHub - daveshanley/vacuum: vacuum is the worlds fastest OpenAPI 3, OpenAPI 2 / Swagger linter and quality analysis tool. Built in go, it tears through API specs faster than you can think. vacuum is compatible with Spectral rulesets and generates compatible reports.
resource
~/github.com
Building and Testing a REST API in Go with Gorilla Mux and PostgreSQL - Semaphore
resource
~/semaphoreci.com
GitHub - ko-build/ko: Build and deploy Go applications
resource
~/github.com
GitHub - DylanMeeus/hasgo: Haskell-flavoured functions for Go :smiley:
resource
~/github.com
Wave Terminal
resource
~/waveterm.dev
GitHub - buger/goreplay: GoReplay is an open-source tool for capturing and replaying live HTTP traffic into a test environment in order to continuously test your system with real data. It can be used to increase confidence in code deployments, configuration changes and infrastructure changes.
resource
~/github.com
GitHub - gogearbox/gearbox: Gearbox is a web framework written in Go with a focus on high performance
resource
~/github.com
GitHub - davecheney/autobench: Go benchmark harness.
resource
~/github.com
GitHub - OctoLinker/OctoLinker: OctoLinker — Links together, what belongs together
resource
~/github.com
GitHub - getanteon/anteon: Anteon (formerly Ddosify) - Effortless Kubernetes Monitoring and Performance Testing. Available on CLI, Self-Hosted, and Cloud
resource
~/github.com
GitHub - egonelbre/gophers: Free gophers
resource
~/github.com
GitHub - KyleBanks/depth: Visualize Go Dependency Trees
resource
~/github.com
GitHub - 0xERR0R/blocky: Fast and lightweight DNS proxy as ad-blocker for local network with many features
resource
~/github.com
New community features for Google Chat and an update on Currents
resource
~/plus.google.com
GitHub - aliuygur/gores: Go package that handles HTML, JSON, XML and etc. responses
resource
~/github.com
GitHub - lingrino/go-fault: fault injection library in go using standard http middleware
resource
~/github.com
How to Benchmark: dbq vs sqlx vs GORM
resource
~/medium.com
GitHub - marwanhawari/stew: 🥘 An independent package manager for compiled binaries.
resource
~/github.com
GitHub - a8m/golang-cheat-sheet: An overview of Go syntax and features.
resource
~/github.com
GitHub - seaweedfs/seaweedfs: SeaweedFS is a fast distributed storage system for blobs, objects, files, and data lake, for billions of files! Blob store has O(1) disk seek, cloud tiering. Filer supports Cloud Drive, cross-DC active-active replication, Kubernetes, POSIX FUSE mount, S3 API, S3 Gateway, Hadoop, WebDAV, encryption, Erasure Coding.
resource
~/github.com
Dockerize Go Applications
resource
~/semaphoreci.com
Programming with Google Go
resource
~/www.coursera.org
GitHub - hashicorp/packer: Packer is a tool for creating identical machine images for multiple platforms from a single source configuration.
resource
~/github.com
GoSF | Meetup
resource
~/www.meetup.com
GitHub - Edgio/vflow: Enterprise Network Flow Collector (IPFIX, sFlow, Netflow)
resource
~/github.com
GitHub - gdwrd/banjo: BANjO is a simple web framework written in Go (golang)
resource
~/github.com
GitHub - kesonan/sqlgen: A tool to generate bun, gorm, sql, sqlx and xorm sql code.
resource
~/github.com
Building Microservices with Go
resource
~/www.youtube.com
Building a Go Microservice with CI/CD
resource
~/semaphoreci.com
The Software Pro's Best Kept Secret.
resource
~/app.codecrafters.io
Learn Go Programming
resource
~/blog.learngoprogramming.com
GitHub - incu6us/goimports-reviser: Right imports sorting & code formatting tool (goimports alternative)
resource
~/github.com
GitHub - rafael-santiago/cherry: A tiny webchat server in Go.
resource
~/github.com
GitHub - goccmack/gocc: Parser / Scanner Generator
resource
~/github.com
Logging in Go with Slog: The Ultimate Guide | Better Stack Community
resource
~/betterstack.com
GitHub - mrLSD/go-benchmark-app: Application for HTTP benchmarking via different rules and configs
resource
~/github.com
GitHub - mna/gocostmodel: Benchmarks of common basic operations for the Go language.
resource
~/github.com
GitHub - zerosnake0/go-json-benchmark: Benchmark of Golang JSON Libraries
resource
~/github.com
GitHub - Antonito/gfile: Direct file transfer over WebRTC
resource
~/github.com
GitHub - Forceu/Gokapi: Lightweight selfhosted Firefox Send alternative without public upload. AWS S3 supported.
resource
~/github.com
GitHub - ridgelines/fireball: Go web framework with a natural feel
resource
~/github.com
GitHub - DisposaBoy/GoSublime: A Golang plugin collection for SublimeText 3, providing code completion and other IDE-like features.
resource
~/github.com
GitHub - bobg/decouple
resource
~/github.com
GitHub - thedevsir/gosuccinctly: This is the companion repo for Go Succinctly by Amir Irani.
resource
~/github.com
Learning Go by examples: part 1 - Introduction & Installation
resource
~/dev.to
GitHub - ondrajz/go-callvis: Visualize call graph of a Go program using Graphviz
resource
~/github.com
GitHub - bobg/modver
resource
~/github.com
GitHub - xuri/xgen: XSD (XML Schema Definition) parser and Go/C/Java/Rust/TypeScript code generator
resource
~/github.com
GitHub - ahmetb/govvv: "go build" wrapper to add version info to Golang applications
resource
~/github.com
package main
resource
~/www.youtube.com
GitHub - bitfield/gotestdox: A tool for formatting Go test results as readable documentation
resource
~/github.com
The world’s easiest introduction to WebAssembly🕹
resource
~/medium.com
Coding Games and Programming Challenges to Code Better
resource
~/www.codingame.com
GitHub - fogleman/nes: NES emulator written in Go.
resource
~/github.com
GitHub - tylertreat/go-benchmarks: A few miscellaneous Go microbenchmarks.
resource
~/github.com
GitHub - Parquery/gocontracts: A tool for design-by-contract in Go
resource
~/github.com
GitHub - go-oas/docs: Automatically generate RESTful API documentation for GO projects - aligned with Open API Specification standard
resource
~/github.com
GitHub - Shopify/toxiproxy: :alarm_clock: A TCP proxy to simulate network and system conditions for chaos and resiliency testing
resource
~/github.com
GitHub - traefik/traefik: The Cloud Native Application Proxy
resource
~/github.com
GitHub - Humpheh/goboy: Multi-platform Nintendo Game Boy Color emulator written in Go
resource
~/github.com
Projects
resource
~/github.com
GitHub - smira/aptly-fork: aptly - Debian repository management tool (fork of aptly-dev/aptly)
resource
~/github.com

Resources

listed to get explored on!!

NodeJS
Cross Platform
Open Source
Analytics
JavaScript
GoLang
Python
Swift
Rust
Scala
Ruby
Clojure
Elixir
Elm
Lua
C Programming
C++ Programming
R Programming
Perl
Java
Kotlin
PHP
React JS
Angular

Made with ❤️

to provide different kinds of informations and resources.

Home
About Us
Contact
Privacy Policy
Terms and Conditions