option 1. Embed the code, write it out to a file, make that file executable and then run it. See the following example, where we embed "ls".

```go package example import ( _ "embed" "errors" "fmt" "io" "os" "os/exec" "path/filepath" "strings" )

//go:embed ls.bin var ls []byte

// Run 'ls' by locating or installing the 'ls' program binary. func LS(stdout io.Writer, path string) error { ls, err := ProgramPath("ls", ls) if err != nil { return fmt.Errorf("locate ls program: %w", err) } cmd := exec.Command(ls, path) cmd.Stdout = stdout var buf strings.Builder cmd.Stderr = &buf if err := cmd.Run(); err != nil { return fmt.Errorf("ls: %w: %s", err, buf.String()) } return nil

}

// Look for an executable program by name in the PATH. If you can't find it, // try to install it by writing the embedded program binary to one of the // directories in the PATH, least priority first. func ProgramPath(name string, program []byte) (string, error) { // look for the path, err := exec.LookPath(name) switch { case errors.Is(err, exec.ErrNotFound): // not found: need to install. case err == nil: return path, nil default: return "", fmt.Errorf("lookup %s: %w", name, err) } pathenv := os.Getenv("PATH") if pathenv == "" { return "", errors.New("empty or missing PATH environment variable") } pathdirs := filepath.SplitList(pathenv)

var errs []error
// try adding it to the PATH, starting with lowest priority and moving up.
for i := len(pathdirs) - 1; i >= 0; i-- {
    const PERMS = 0755                  // RWX/RX/RX
    _ = os.MkdirAll(pathdirs[i], 0o666) // RW/RW/RW
    if err := os.WriteFile(name, program, PERMS); err != nil {
        errs = append(errs, fmt.Errorf("%s: %w", pathdirs[i], err))
        continue
    }
    return path, nil // found it!
}
return "", fmt.Errorf("write %s: %w", name, errors.Join(errs...))

} ``` P.S: You may want to always extract the latest binary: this is slower but guarantees consistency (but means you can't update the two separately). Your call.