This page lists the Go libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.

What the marks mean.

The test code is made up for the purpose: one small service per library, with the names invented. So "supported" means Niro recognised it there. It is good evidence, but it is not a promise about every codebase. If Niro misses something in your code, the coverage audit reports the gap on its own (see Coverage audit).

The test catalog also holds 9 look-alike cases for Go: code that Niro must NOT take for a route, a call or a store. They test that Niro ignores the look-alike, so they are left out of this page and its counts.

Web frameworks and HTTP servers (the routes your code serves)

19 supported, 0 partly, 9 not yet.

Name Status Ways of using it that were tested
AWS SAM template.yaml supported yes: AWS::Serverless::Function (Runtime provided.al2023, Handler bootstrap, Metadata BuildMethod go1.x) with Events Type HttpApi Path and Method; the handler is the package main under CodeUri
encore.dev not yet no: //encore:api comment directive above a function
github.com/beego/beego/v2 supported yes: web.Router with a controller and 'verb:Method' mapping
yes: web.Get functional route with a literal
yes: NewNamespace with NSRouter
github.com/cloudwego/hertz supported yes: verbs on server.Default() held in h
yes: Group then verb
github.com/danielgtaylor/huma/v2 supported yes: huma.Get(api, path, handler) package helper
yes: huma.Register with an Operation literal naming Method and Path
github.com/dapr/go-sdk not yet no: service AddServiceInvocationHandler(path, h)
github.com/fasthttp/router supported yes: fasthttp/router verbs and Group
github.com/gin-gonic/gin supported yes: engine verb methods with a method-value handler
yes: inline function literal handler
yes: Handle with the verb as a string
yes: Any registers every verb
yes: route group with a block
yes: *gin.RouterGroup passed to a register function in another file
github.com/go-chi/chi/v5 supported yes: chi verb methods
yes: Route with a function literal, nested twice
yes: Method with a verb constant and an http.Handler
yes: inline middleware chain before the verb
yes: Mount a sub-router returned by a function
github.com/go-kit/kit (transport/http) not yet no: go-kit httptransport.NewServer mounted on a gorilla route
github.com/go-kratos/kratos (HTTP transport) not yet no: kratos generated *_http.pb.go registering routes
github.com/go-martini/martini supported yes: verbs on martini.Classic() held in m
yes: Group with a function literal
github.com/gobuffalo/buffalo not yet no: buffalo app verbs
github.com/gofiber/fiber/v2 supported yes: Fiber verb methods
yes: Add with a verb constant
yes: Group
yes: Route with a function literal
github.com/gofiber/fiber/v3 not yet no: fiber v3 verbs (handler takes fiber.Ctx interface)
github.com/gorilla/mux supported yes: HandleFunc(...).Methods(verb)
yes: Handle(path, http.HandlerFunc(m)).Methods(verb)
yes: chain starting with Methods, then Path, then HandlerFunc
yes: PathPrefix(...).Subrouter()
github.com/julienschmidt/httprouter supported yes: httprouter verb methods
yes: Handle with a verb constant
yes: HandlerFunc with a plain http.HandlerFunc
github.com/kataras/iris/v12 supported yes: iris verbs and Party
yes: Handle with a verb string
github.com/labstack/echo/v4 supported yes: Echo verb methods
yes: Add with a verb constant
yes: Match with a verb list
yes: Group with a prefix
github.com/oapi-codegen/oapi-codegen (generated server) not yet no: generated RegisterHandlers: router.GET(baseURL+path, wrapper.X) inside checked-in generated code
github.com/revel/revel not yet no: conf/routes file
github.com/uptrace/bunrouter supported yes: bunrouter verbs
yes: WithGroup with a function literal
github.com/zeromicro/go-zero supported yes: AddRoutes with a []rest.Route literal and rest.WithPrefix
yes: AddRoute with one rest.Route literal
goa.design/goa/v3 not yet no: goa design DSL plus generated server
gofr.dev supported yes: gofr app verbs
Netlify Functions (Go, Lambda compatibility) supported yes: netlify/functions/<name>/main.go (or <name>.go) with lambda.Start: served at /.netlify/functions/<name>, every verb; a -background suffix makes a background function
yes: netlify.toml [[redirects]] from a path to /.netlify/functions/<name> with status 200 gives the function that path too
yes: netlify.toml [functions] directory = "<folder>" moves where function folders are read from
Serverless Framework serverless.yml supported yes: functions.<name> with handler bootstrap and package.artifact, events httpApi; runtime provided.al2023
Vercel Functions (Go runtime, /api directory) supported yes: api/<name>.go with an exported func(http.ResponseWriter, *http.Request): the file path is the route, every verb
yes: api/cards/[id].go: a bracketed file name is a dynamic path segment

The language's own HTTP server

0 supported, 2 partly, 0 not yet.

Name Status Ways of using it that were tested
net/http partly yes: http.HandleFunc on the default mux, inline func literal handler
yes: http.Handle with a type implementing http.Handler (ServeHTTP)
yes: ServeMux.HandleFunc with Go 1.22 pattern 'METHOD /path/{wildcard}'
yes: ServeMux.Handle with a method pattern and an http.Handler value
yes: http.HandlerFunc(fn) adapter passed to Handle
yes: Go 1.22 trailing wildcard {name...}
yes: Go 1.22 exact-match marker {$}
yes: Go 1.22 host-qualified pattern
partly: pre-1.22 single path, verb chosen by switch r.Method in the handler
yes: second ServeMux mounted under a prefix with http.StripPrefix
net/rpc partly yes: rpc.Register + rpc.HandleHTTP: every exported method T.M(args, *reply) error is a procedure
yes: rpc.RegisterName with a custom service name
no: rpc.NewServer + jsonrpc.NewServerCodec over raw TCP

HTTP client libraries (the calls your code makes to other services)

2 supported, 5 partly, 8 not yet.

Name Status Ways of using it that were tested
github.com/carlmjohnson/requests supported yes: requests.URL(base).Pathf().ToJSON().Fetch(ctx)
yes: BodyJSON().Post().Fetch
github.com/cloudwego/hertz (client) partly yes: hertz client.Get(ctx, dst, url)
no: protocol.Request SetMethod/SetRequestURI then client Do
github.com/dapr/go-sdk not yet no: client.InvokeMethod(ctx, appID, method, verb): service invocation by app name
github.com/dghubble/sling not yet no: sling.New().Base(url); New().Get(path).ReceiveSuccess
no: Post(path).BodyJSON().ReceiveSuccess
github.com/go-kit/kit (transport/http client) not yet no: httptransport.NewClient(verb, url, enc, dec)
github.com/go-resty/resty/v2 partly yes: client with SetBaseURL; R().SetPathParam().Get(path)
yes: R().SetBody().Post
yes: R().SetContext().SetBody().Put
no: R().Execute(verb, url)
yes: fresh client, full literal URL
github.com/gojek/heimdall/v7 not yet no: httpclient.NewClient().Get(url, headers)
no: Post(url, body, headers)
github.com/hashicorp/go-cleanhttp not yet no: cleanhttp.DefaultPooledClient() returns *http.Client; then Get
github.com/hashicorp/go-retryablehttp partly yes: package-level retryablehttp.Get
yes: NewClient then Post
no: retryablehttp.NewRequest then Do
no: StandardClient() gives a plain *http.Client
github.com/imroc/req/v3 partly no: req.C().SetBaseURL(); R().SetPathParam().Get
no: R().SetBody().Post
yes: package-level req.Get with a full URL
no: fluent client.Delete(url).Do()
github.com/parnurzeal/gorequest supported yes: gorequest.New().Get(url).End()
yes: Post(url).Send(json).End()
github.com/valyala/fasthttp (client) partly yes: fasthttp.Get(dst, url)
no: AcquireRequest, SetRequestURI, SetMethod, Client.Do
github.com/zeromicro/go-zero/rest/httpc not yet no: httpc.Do(ctx, verb, url-with-:id, reqStruct)
gopkg.in/h2non/gentleman.v2 not yet no: URL, Request, Method, Path, Send
oapi-codegen generated client not yet no: generated NewClientWithResponses(server) + GetSupplierWithResponse; generated code calls http.NewRequest

The language's own HTTP client

0 supported, 2 partly, 0 not yet.

Name Status Ways of using it that were tested
net/http partly yes: http.Get with a literal URL
yes: http.Get with literal base plus string concatenation
no: http.Get with fmt.Sprintf building the URL
yes: http.Post with a base held in a package constant
partly: http.PostForm
yes: http.Head
no: http.NewRequest with a verb constant, then a configured http.Client's Do
no: http.NewRequestWithContext with a verb literal, then http.DefaultClient.Do, base from os.Getenv
no: url.JoinPath builds the URL, http.Client value's Get
yes: *http.Client held on a struct field, base on another field set from config
no: net/http/httputil reverse proxy to a fixed target
yes: plain http.Get to a grpc-gateway REST mapping
net/rpc partly no: rpc.DialHTTP then client.Call("Type.Method", args, &reply)
partly: asynchronous client.Go
yes: jsonrpc.Dial then Call

gRPC

2 supported, 3 partly, 4 not yet.

Name Status Ways of using it that were tested
connectrpc.com/connect (client) supported yes: connect-go: {pkg}connect.New{S}Client(http.DefaultClient, baseURL) then client.M(ctx, connect.NewRequest(...)) (plan 8.4)
yes: the same client with connect.WithGRPC()
connectrpc.com/connect (server) supported yes: connect-go: path, h := {pkg}connect.New{S}Handler(&impl{}); mux.Handle(path, h) (plan 8.4)
github.com/go-kratos/kratos (gRPC transport) not yet no: kratos gRPC transport: pb.Register{S}Server(grpcSrv, svc) via kratos grpc.NewServer
github.com/grpc-ecosystem/grpc-gateway/v2 partly yes: grpc-gateway REST mapping from option (google.api.http) in the .proto, incl. additional_bindings (plan 8.4)
yes: pb.Register{S}HandlerFromEndpoint(ctx, mux, addr, opts)
no: pb.Register{S}HandlerServer(ctx, mux, impl) in-process
github.com/twitchtv/twirp not yet no: twirp New{S}Server(impl) mounted at server.PathPrefix(); path /twirp/{pkg}.{S}/{M}
no: twirp New{S}ProtobufClient(baseURL, httpClient) then client.M
go-micro.dev/v4 not yet no: go-micro service handler registration
google.golang.org/grpc (client) partly yes: conn from grpc.NewClient(literal target), then pb.New{S}Client(conn) stored on a struct field typed pb.{S}Client
yes: server-streaming client call returning a stream
yes: deprecated grpc.Dial(os.Getenv(...)) and a local client variable
no: grpc.DialContext with a dns:/// target (plan 8.6)
yes: conn.Invoke with the full wire path literal (plan 8.3 literal_path)
no: dynamic client through grpcreflect (plan 8.3: not covered)
google.golang.org/grpc (server) partly yes: server struct embedding pb.Unimplemented{S}Server, unary method (plan row grpc-go-unimplemented)
no: pb.Register{S}Server(s, impl) registration (plan section 3, go)
yes: server-streaming method M(req, stream pb.S_MServer) error (plan 8.2)
yes: client-streaming method M(stream pb.S_MServer) error (plan 8.2)
yes: bidirectional streaming method (plan 8.2)
yes: hand-written grpc.ServiceDesc literal + RegisterService (plan 8.3, keyed-literal reader)
no: grpc_health_v1.RegisterHealthServer(s, health.NewServer())
yes: reflection.Register(s) must NOT become a route (plan 8.3)
yes: checked-in generated orders_grpc.pb.go: the Unimplemented base's methods and the generated client's c.cc.Invoke must NOT become routes or calls (plan trap T5)
storj.io/drpc not yet no: storj drpc generated DRPC{S} interfaces

Databases and data stores

13 supported, 10 partly, 25 not yet.

Name Status Ways of using it that were tested
cloud.google.com/go/bigquery not yet no: client.Query(sql).Read
no: Dataset().Table().Inserter().Put
cloud.google.com/go/firestore supported yes: Collection().Doc().Get/Set
yes: Collection().Where().Documents().GetAll
cloud.google.com/go/spanner partly partly: Single().Query(ctx, spanner.Statement{SQL: ...})
yes: spanner.Insert(table, cols, vals) passed to Apply
database/sql partly yes: sql.Open + QueryContext with the query in a constant
yes: ExecContext with an inline INSERT
yes: transaction: BeginTx, PrepareContext(DELETE), QueryRowContext(SELECT count)
partly: main reads or writes a table or collection that a service also owns (the cross-service data link)
entgo.io/ent not yet no: client.Review.Query().Where().All / Create().Save
github.com/aerospike/aerospike-client-go/v7 not yet no: github.com/aerospike/aerospike-client-go/v7 basic read/write
github.com/aws/aws-sdk-go (v1 dynamodb, s3) not yet no: github.com/aws/aws-sdk-go (v1 dynamodb, s3) basic read/write
github.com/aws/aws-sdk-go-v2/service/dynamodb supported yes: PutItem with TableName: aws.String(literal)
yes: GetItem with TableName from a constant
yes: Query
github.com/aws/aws-sdk-go-v2/service/s3 partly yes: PutObject with Bucket literal
no: GetObject with Bucket from os.Getenv
yes: manager.NewUploader(client).Upload
github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos not yet no: github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos basic read/write
github.com/Azure/azure-sdk-for-go/sdk/storage/azblob not yet no: github.com/Azure/azure-sdk-for-go/sdk/storage/azblob basic read/write
github.com/bradfitz/gomemcache partly partly: mc.Set(&memcache.Item{Key: k}) and mc.Get(k)
github.com/ClickHouse/clickhouse-go/v2 supported yes: conn.Query(ctx, sql)
yes: PrepareBatch(ctx, "INSERT INTO t")
github.com/dgraph-io/badger not yet no: github.com/dgraph-io/badger basic read/write
github.com/doug-martin/goqu/v9 supported yes: goqu From(table).Where().ScanVals
yes: Insert(table).Rows().Executor().Exec()
github.com/elastic/go-elasticsearch/v8 partly partly: es.Index(index, body)
yes: es.Search(es.Search.WithIndex(name))
no: typed client Search().Index(name).Do
github.com/go-pg/pg/v10 not yet no: db.Model(&v).Where().Select() and Insert with pg:"table" tag
github.com/go-sql-driver/mysql supported yes: sql.Open("mysql", dsn) then Query
github.com/gocql/gocql supported yes: session.Query(cql).Exec() / .Iter()
github.com/gocraft/dbr/v2 not yet no: github.com/gocraft/dbr/v2 basic read/write
github.com/gomodule/redigo not yet no: conn.Do("COMMAND", key, ...)
github.com/hashicorp/consul/api (KV) not yet no: github.com/hashicorp/consul/api (KV) basic read/write
github.com/influxdata/influxdb-client-go/v2 not yet no: github.com/influxdata/influxdb-client-go/v2 basic read/write
github.com/jackc/pgx/v5 partly yes: pgx.Connect then conn.QueryRow
yes: pgxpool.New then pool.Exec
yes: pool.Query
no: pgx.Batch Queue
yes: CopyFrom with pgx.Identifier{table}
github.com/jmoiron/sqlx partly yes: db.Select(&dest, query)
no: db.Get with db.Rebind(query)
yes: NamedExec INSERT
yes: Queryx
yes: MustExec
github.com/lib/pq supported yes: Exec with pq.Array argument
yes: COPY with pq.CopyIn(table, cols...)
github.com/Masterminds/squirrel partly yes: Select().From(table).RunWith(db).Query()
no: Insert(table).ToSql() then db.Exec
github.com/mattn/go-sqlite3 and modernc.org/sqlite supported yes: sql.Open("sqlite3", file) then Exec
yes: sql.Open("sqlite", file) then QueryRow
github.com/meilisearch/meilisearch-go not yet no: github.com/meilisearch/meilisearch-go basic read/write
github.com/milvus-io/milvus-sdk-go/v2 not yet no: github.com/milvus-io/milvus-sdk-go/v2 basic read/write
github.com/minio/minio-go/v7 supported yes: minio PutObject/GetObject(ctx, bucket, object, ...)
github.com/neo4j/neo4j-go-driver/v5 supported yes: neo4j.ExecuteQuery(ctx, driver, cypher) and session.Run(ctx, cypher)
github.com/olivere/elastic/v7 not yet no: github.com/olivere/elastic/v7 basic read/write
github.com/opensearch-project/opensearch-go not yet no: github.com/opensearch-project/opensearch-go basic read/write
github.com/qdrant/go-client not yet no: github.com/qdrant/go-client basic read/write
github.com/redis/go-redis/v9 supported yes: Set/Get/HSet/LPush with literal or built keys
yes: Pipeline commands then Exec
yes: NewClusterClient then Del
github.com/redis/rueidis not yet no: client.Do(ctx, client.B().Set().Key(k).Value(v).Build())
github.com/upper/db/v4 not yet no: github.com/upper/db/v4 basic read/write
github.com/uptrace/bun partly yes: NewSelect().Model(&slice) with bun:"table:..." tag
partly: NewInsert().Model(&v).Exec
yes: NewSelect().Table(name)
yes: NewRaw SQL
github.com/volatiletech/sqlboiler/v4 not yet no: github.com/volatiletech/sqlboiler/v4 basic read/write
go.etcd.io/bbolt not yet no: tx.Bucket([]byte(name)).Put/Get inside Update/View closures
go.etcd.io/etcd/client/v3 not yet no: clientv3 Put/Get with key or prefix
go.mongodb.org/mongo-driver supported yes: Database().Collection() then FindOne/InsertOne/UpdateOne
yes: one-line chain Database().Collection().Aggregate
go.mongodb.org/mongo-driver/v2 supported yes: mongo-driver v2 (Connect without ctx), Find/DeleteMany
gocloud.dev/blob not yet no: gocloud.dev/blob basic read/write
gorm.io/gorm partly yes: model-based queries: First, Where().Order().Find
yes: Create(&model)
yes: Model(&Order{}).Where().Update
yes: Delete(&Order{}, id)
yes: Table(name) names the table
yes: Raw SQL through GORM
yes: Exec SQL through GORM
no: model with TableName() override
sqlc (generated code) not yet no: sqlc generated Queries: SQL in const strings, called through q.db.QueryRow/Exec
xorm.io/xorm not yet no: engine.Where().Get(&model) with TableName()
no: engine.Table(name).Where().Count()

Messaging and events (queues, topics, streams)

5 supported, 14 partly, 15 not yet.

Name Status Ways of using it that were tested
channels (in-process bus) not yet no: in-process event bus on channels shared between packages (Publish/Subscribe by topic string)
cloud.google.com/go/pubsub partly no: client.Topic(name).Publish(ctx, msg), inline or through a variable
partly: client.Subscription(name).Receive(ctx, cb)
cloud.google.com/go/pubsub/v2 (Publisher/Subscriber API) not yet no: cloud.google.com/go/pubsub/v2 (Publisher/Subscriber API) basic use
github.com/apache/pulsar-client-go supported yes: CreateProducer(pulsar.ProducerOptions{Topic}) then Send
yes: client.Subscribe(pulsar.ConsumerOptions{Topic, SubscriptionName}) then Receive
github.com/aws/aws-sdk-go v1 (sqs, sns) not yet no: github.com/aws/aws-sdk-go v1 (sqs, sns) basic use
github.com/aws/aws-sdk-go-v2 (sqs, sns, eventbridge, kinesis) partly yes: SQS SendMessage with QueueUrl literal
no: SQS ReceiveMessage with QueueUrl from os.Getenv
yes: SNS Publish with TopicArn literal
no: EventBridge PutEvents with EventBusName and DetailType
yes: Kinesis PutRecord with StreamName
github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus partly yes: client.NewSender(queue).SendMessage
no: NewReceiverForQueue(queue).ReceiveMessages
github.com/centrifugal/centrifuge not yet no: github.com/centrifugal/centrifuge basic use
github.com/cloudevents/sdk-go/v2 not yet no: cloudevents.NewClientHTTP(WithPort) + StartReceiver(ctx, fn)
no: c.Send(cloudevents.ContextWithTarget(ctx, url), event)
github.com/confluentinc/confluent-kafka-go/v2 supported yes: Produce(&kafka.Message{TopicPartition: kafka.TopicPartition{Topic: &topic}})
yes: SubscribeTopics([]string{...}, nil)
yes: Subscribe(topic, nil)
github.com/dapr/go-sdk partly yes: Dapr client.PublishEvent(ctx, pubsub, topic, data)
partly: service AddTopicEventHandler(&common.Subscription{PubsubName, Topic, Route}, h)
github.com/eclipse/paho.mqtt.golang partly partly: client.Publish(topic, qos, retained, payload)
no: client.Subscribe(filter-with-+, qos, cb)
github.com/go-co-op/gocron (scheduler) not yet no: github.com/go-co-op/gocron (scheduler) basic use
github.com/go-redis/redis/v8 not yet no: github.com/go-redis/redis/v8 basic use
github.com/gocraft/work not yet no: github.com/gocraft/work basic use
github.com/hibiken/asynq partly yes: client.Enqueue(asynq.NewTask(type, payload))
yes: mux.HandleFunc(type, fn)
no: mux.Handle(constType, handlerType)
github.com/IBM/sarama partly yes: SyncProducer.SendMessage(&sarama.ProducerMessage{Topic: ...})
yes: ProducerMessage built in a variable, then SendMessage(msg)
no: AsyncProducer.Input() <- msg
no: ConsumerGroup.Consume(ctx, []string{topic}, handler) with a ConsumerGroupHandler
yes: Consumer.ConsumePartition(topic, partition, offset)
github.com/lib/pq (LISTEN/NOTIFY) supported yes: pq.NewListener + Listen(channel): Postgres LISTEN/NOTIFY as an event bus
github.com/nats-io/nats.go partly yes: nc.Publish(subject, data)
partly: nc.Subscribe(subject, callback)
no: nc.QueueSubscribe(subject, queue, cb)
no: nc.Request(subject, data, timeout) and a responder that calls m.Respond
yes: nc.JetStream() then js.Publish / js.Subscribe
partly: jetstream.New(nc); stream.CreateOrUpdateConsumer(ConsumerConfig{FilterSubject}); cons.Consume(cb); js.Publish(ctx, subj, data)
github.com/nsqio/go-nsq partly yes: producer.Publish(topic, body)
no: nsq.NewConsumer(topic, channel, cfg) + AddHandler(HandleMessage)
github.com/rabbitmq/amqp091-go partly yes: PublishWithContext(ctx, exchange, routingKey, ...)
yes: Consume(queue, ...)
no: QueueBind(queue, routingKey, exchange): joins a routing key to a queue
github.com/redis/go-redis/v9 (pub/sub, streams) partly yes: rdb.Publish(ctx, channel, msg)
yes: rdb.Subscribe(ctx, channel) then sub.Channel()
yes: XAdd(ctx, &redis.XAddArgs{Stream: ...})
no: XReadGroup(ctx, &redis.XReadGroupArgs{Streams: []string{name, ">"}})
github.com/RichardKnop/machinery/v2 not yet no: server.SendTask(&tasks.Signature{Name}) and RegisterTask(name, fn)
github.com/riverqueue/river partly partly: client.Insert(ctx, args, nil) where args has Kind() string
no: river.AddWorker(workers, &Worker{}) with Work(ctx, *river.Job[Args])
github.com/robfig/cron/v3 (scheduler) not yet no: github.com/robfig/cron/v3 (scheduler) basic use
github.com/segmentio/kafka-go partly yes: kafka.NewReader(kafka.ReaderConfig{Topic}) then ReadMessage/FetchMessage
partly: kafka.Writer{Topic: ...} then WriteMessages
yes: Writer with no topic; Topic on each kafka.Message
github.com/Shopify/sarama (old import path) not yet no: github.com/Shopify/sarama (old import path) basic use
github.com/streadway/amqp supported yes: legacy streadway/amqp Consume and Publish (same API as amqp091)
github.com/ThreeDotsLabs/watermill partly partly: publisher.Publish(topic, msg)
partly: router.AddHandler(name, subTopic, sub, pubTopic, pub, fn)
no: router.AddNoPublisherHandler(name, topic, sub, fn)
github.com/twmb/franz-go supported yes: kgo.NewClient(kgo.ConsumeTopics(...)) then PollFetches
yes: Produce/ProduceSync(ctx, &kgo.Record{Topic: ...})
go-micro.dev broker not yet no: go-micro.dev broker basic use
go.etcd.io/etcd/client/v3 (Watch) not yet no: clientv3 Watch on a prefix (change notifications)
go.temporal.io/sdk (workflows and activities) not yet no: go.temporal.io/sdk (workflows and activities) basic use
slack-go, twilio-go, sendgrid-go (SaaS API calls) not yet no: slack-go, twilio-go, sendgrid-go (SaaS API calls) basic use

Build tools and package managers

8 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
bazel (rules_go + gazelle) supported yes: MODULE.bazel + BUILD.bazel with go_binary / go_library / go_test, one root go.mod
bazel (WORKSPACE, legacy) supported yes: WORKSPACE + BUILD files and no go.mod at all
dep / glide (pre-modules) supported yes: Gopkg.toml (dep) and glide.yaml, no go.mod, GOPATH import paths
go modules supported yes: one go.mod at the root, package main plus one sub-package
yes: several go.mod in one repo, joined by one-line replace X => ../path
yes: replace written as a block: replace ( X => ../path )
yes: vendored dependencies in vendor/ with vendor/modules.txt
go workspaces supported yes: go.work with a use ( ... ) block, no replace directives
yes: go.work with one use per line and a workspace-level replace
goreleaser supported yes: .goreleaser.yaml declaring two builds (main: ./cmd/x) from one module
mage supported yes: magefile.go (//go:build mage, package main) at the root of a library module
make / Task supported yes: Makefile and Taskfile.yml that build two binaries from one module

Project and folder layouts

6 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
go build supported yes: bin/ and dist/ build output, and a coverage profile
go build (cgo) supported yes: Go package with import "C" and .c/.h files beside it
go build (tags) supported yes: platform files: _windows.go, _linux.go, and //go:build js && wasm
go modules supported yes: golang-standards layout: cmd/, internal/, pkg/, api/, configs/, scripts/, test/
yes: one go.mod with two programs under cmd/api and cmd/worker sharing internal/
yes: a module nested inside another module's folder (examples/ and tools/ with their own go.mod)
yes: tools.go with //go:build tools importing code generators
yes: major version in a subdirectory: v2/ with its own go.mod (module .../v2)
yes: a library with examples/<name>/main.go programs inside the same module
go test supported yes: _test.go beside code, external test package (package x_test), testdata/ holding .go fixtures
protoc / go generate supported yes: generated *.pb.go and // Code generated ... DO NOT EDIT. files inside the module, plus a //go:generate line

Deployment files

17 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
aws sam supported yes: template.yaml with AWS::Serverless::Function CodeUri per service
docker buildx bake supported yes: docker-bake.hcl targets with context
docker compose supported yes: docker-compose.yml, build: ./services/x string form, plus image-only infra
yes: build: {context: ., dockerfile: services/x/Dockerfile}: context is the repo root
yes: deploy/docker-compose.yml with ../services/x contexts
yes: compose.yaml plus compose.override.yaml, profiles, extends, and an image: + build: service
dockerfile supported yes: a Dockerfile in each service folder and nothing else
yes: docker/<svc>/Dockerfile kept apart from the code
fly.io supported yes: fly.toml per service with app = "name"
github actions supported yes: dorny/paths-filter with one named filter per service
yes: a build matrix over services with working-directory: services/${{ matrix.service }}
gitlab ci supported yes: .gitlab-ci.yml jobs with rules:changes per service
google app engine supported yes: app.yaml per service (runtime go122, service: name) plus dispatch.yaml
helm supported yes: charts/<svc>/Chart.yaml type application, one library chart, one umbrella chart with dependencies
heroku procfile supported yes: Procfile inside each service folder (web and worker process types)
kubernetes supported yes: multi-document manifest: Deployment shop-orders-api (name differs from folder), Service, CronJob billing
kubernetes (kustomize) supported yes: kustomize base + overlays; workloads in base, overlays patch them
kubernetes + ko supported yes: image: ko://example.com/shop/orders naming the Go import path to build
render supported yes: one render.yaml at the root listing services with rootDir
serverless framework supported yes: serverless.yml per service, provider.runtime provided.al2, functions with handler bootstrap
skaffold supported yes: skaffold.yaml build.artifacts with context per service
vercel supported yes: vercel.json with Go serverless functions in api/*.go