Wire is runtime depedency injection/wiring for golang. It's designed to be strict to avoid your go application running without proper dependency injected.

Programming language: Go
License: MIT License
Latest version: v1.0.2

wire alternatives and similar packages

Based on the "Utilities" category.
Alternatively, view wire alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of wire or a related project?

Add another 'Utilities' Package



GoDoc Build Status Go Report Card Maintainability Test Coverage FOSSA Status

Wire is runtime depedency injection/wiring for golang. It's designed to be strict to avoid your go application running without proper dependency injected.


  • Strictly validates dependency and prevents missing or ambiguous dependency.
  • Check againts possible forgotten wire tag.
  • Easily connect and resolve object anywhere.
  • Annotates ambiguous interface type using connection name or implementation name.


go get github.com/Fs02/wire


package wire_test

import (


type Listener struct{}

func (listener Listener) Next() string {
    return "system"

type Printer interface {
    Exec(string) error

type SystemPrint struct {
    App string `wire:""`

func (systemPrint SystemPrint) Exec(msg string) error {
    fmt.Println("[" + systemPrint.App + "] System: " + msg)
    return nil

type UserPrint struct {
    App    string `wire:""`
    Target string

func (userPrint UserPrint) Exec(msg string) error {
    fmt.Println("[" + userPrint.App + "]" + userPrint.Target + ": " + msg)
    return nil

type Service struct {
    // Each of `wire`` tag below indicate fields to be wired with apporpriate component.
    // value inside `wire` tag indicate the name of the component and optionally it's type.
    // `wire` with empty value will be wired with default value (named using empty string).
    // Ambiguous field can be resolved by adding it's type, name or both (separated using comma) to the `wire` tag.
    // Don't worry if you forgot to add wire tag to an interface or a pointer, wire will warn you if any nil field are found.
    // To ignore wiring on specific field, you can use add `wire:"-"`.
    Listener     Listener `wire:""`
    SystemPrint  Printer  `wire:",SystemPrint"`
    FooUserPrint Printer  `wire:"foo"`
    BooUserPrint Printer  `wire:"boo,UserPrint"`

func (service Service) Update() error {
    switch service.Listener.Next() {
    case "system":
        return service.SystemPrint.Exec("hello from system")
    case "user-foo":
        return service.FooUserPrint.Exec("hello from foo")
    case "user-boo":
        return service.BooUserPrint.Exec("hello from boo")
        return nil

func init() {
    // add components to be wired by the library.
    // wire all components only once and as early as possible.
    wire.Connect(Listener{})                       // we don't need to pass by reference here, since it doesn't require any wiring.
    wire.Connect(&SystemPrint{})                   // we need to pass by reference it to allow wiring, wire will panic if we pass by value.
    wire.Connect(&UserPrint{Target: "foo"}, "foo") // wire a UserPrint named by "foo".
    wire.Connect(&UserPrint{Target: "boo"}, "boo") // wire a UserPrint named by "boo", wire will panic if there's duplicate components detected.

    // Apply wiring

func Example() {
    // Resolve a service component to be used later.
    var service Service

    // Output: [CoolApp] System: hello from system


Released under the MIT License

FOSSA Status

*Note that all licence references and agreements mentioned in the wire README section above are relevant to that project's source code only.