Subject: [bug#28586] [PATCH 2/2] gnu: Add Syncthing.

From: Leo Famulari <[email-masked]>
Date: Sun, 24 Sep 2017 16:40:53 -0400

* gnu/packages/syncthing.scm: New file.

Co-authored-by: Petter <[email-masked]>
---
 gnu/local.mk               |    1 +
 gnu/packages/syncthing.scm | 1853 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 1854 insertions(+)
 create mode 100644 gnu/packages/syncthing.scm

diff --git a/gnu/local.mk b/gnu/local.mk
index acae77326..14aa0303f 100644
--- a/gnu/local.mk
+++ b/gnu/local.mk
@@ -381,6 +381,7 @@ GNU_SYSTEM_MODULES =				\
   %D%/packages/suckless.scm			\
   %D%/packages/swig.scm				\
   %D%/packages/sync.scm			\
+  %D%/packages/syncthing.scm			\
   %D%/packages/synergy.scm			\
   %D%/packages/syndication.scm			\
   %D%/packages/task-management.scm		\
diff --git a/gnu/packages/syncthing.scm b/gnu/packages/syncthing.scm
new file mode 100644
index 000000000..bd02e6e9f
--- /dev/null
+++ b/gnu/packages/syncthing.scm
@@ -0,0 +1,1853 @@
+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2016 Petter <[email-masked]>
+;;; Copyright © 2016, 2017 Leo Famulari <[email-masked]>
+;;;
+;;; This file is part of GNU Guix.
+;;;
+;;; GNU Guix is free software; you can redistribute it and/or modify it
+;;; under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 3 of the License, or (at
+;;; your option) any later version.
+;;;
+;;; GNU Guix is distributed in the hope that it will be useful, but
+;;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
+
+(define-module (gnu packages syncthing)
+  #:use-module (guix build-system go)
+  #:use-module (guix build-system trivial)
+  #:use-module (guix packages)
+  #:use-module (guix download)
+  #:use-module (guix git-download)
+  #:use-module (guix licenses))
+
+(define-public syncthing
+  (package
+    (name "syncthing")
+    (version "0.14.37")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://github.com/syncthing/syncthing"
+                                  "/releases/download/v" version
+                                  "/syncthing-source-v" version ".tar.gz"))
+              (sha256
+               (base32
+                "02xs4x49va9cnapx6g19b62ln85wskxnr94nrz4mxdlsn7qgw92l"))))
+    (build-system go-build-system)
+    (arguments
+     `(#:import-path "github.com/syncthing/syncthing"
+       #:unpack-path "github.com/syncthing"
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'delete-bundled-source-code
+           (lambda _
+             ;; Keep the bundled cznic libraries. There are some "internal"
+             ;; cznic libraries that complicate the use of non-bundled copies.
+             (rename-file "src/github.com/syncthing/syncthing/vendor/github.com/cznic"
+                          "cznic")
+             (delete-file-recursively "src/github.com/syncthing/syncthing/vendor")
+             (mkdir-p "src/github.com/syncthing/syncthing/vendor/github.com/")
+             (rename-file "cznic"
+                          "src/github.com/syncthing/syncthing/vendor/github.com/cznic")
+             #t))
+
+         ;; We don't need to install the source code for end-user applications.
+         (delete 'install-source)
+
+         (add-before 'build 'increase-test-timeout
+           (lambda _
+             (substitute* "src/github.com/syncthing/syncthing/build.go"
+               (("60s") "999s"))
+             #t))
+
+         (replace 'build
+           (lambda* (#:key inputs #:allow-other-keys)
+             (with-directory-excursion "src/github.com/syncthing/syncthing"
+               (zero? (system* "go" "run" "build.go" "-no-upgrade")))))
+
+         (replace 'check
+           (lambda _
+             (with-directory-excursion "src/github.com/syncthing/syncthing"
+               (zero? (system* "go" "run" "build.go" "test")))))
+
+         (replace 'install
+           (lambda _
+             (copy-recursively "src/github.com/syncthing/syncthing/bin/"
+                               (string-append (assoc-ref %outputs "out") "/bin"))
+             #t))
+
+         (add-after 'install 'install-docs
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (man (string-append out "/share/man/man"))
+                    (src "src/github.com/syncthing/syncthing/man/"))
+               (for-each
+                 (lambda (file)
+                   (install-file file
+                                 (string-append man (string-take-right file 1))))
+                 (find-files src "\\.[1-9]"))
+             #t))))))
+    (inputs
+     `(("github-com-AudriusButkevicius-go-nat-pmp"
+        ,golang-github-com-audriusbutkevicius-go-nat-pmp)
+       ("golang-github-com-vitrun-qart" ,(golang-github-com-vitrun-qart))
+       ("github-com-thejerf-suture" ,golang-github-com-thejerf-suture)
+       ("github-com-syndtr-goleveldb" ,golang-github-com-syndtr-goleveldb)
+       ("github-com-sasha-s-go-deadlock" ,golang-github-com-sasha-s-go-deadlock)
+       ("github-com-rcrowley-go-metrics" ,golang-github-com-rcrowley-go-metrics)
+       ("github-com-minio-sha256-simd" ,golang-github-com-minio-sha256-simd)
+       ("github-com-kardianos-osext" ,golang-github-com-kardianos-osext)
+       ("golang-github-com-kballard-go-shellquote"
+        ,golang-github-com-kballard-go-shellquote)
+       ("github-com-jackpal-gateway" ,golang-github-com-jackpal-gateway)
+       ("github-com-gobwas-glob" ,golang-github-com-gobwas-glob)
+       ("github-com-calmh-xdr" ,golang-github-com-calmh-xdr)
+       ("github-com-calmh-luhn" ,golang-github-com-calmh-luhn)
+       ("github-com-calmh-du" ,golang-github-com-calmh-du)
+       ("github-com-bkaradzic-go-lz4" ,golang-github-com-bkaradzic-go-lz4)
+       ("github-com-golang-snappy" ,golang-github-com-golang-snappy)
+       ("golang-org-x-crypto" ,(golang-org-x-crypto))
+       ("golang-org-x-text" ,(golang-org-x-text))
+       ("golang.org-x-net" ,(golang-org-x-net))
+       ("golang-github-com-gogo-protobuf-protoc-gen-gogo"
+        ,golang-github-com-gogo-protobuf-protoc-gen-gogo)
+       ("golang-github-com-gogo-protobuf"
+        ,golang-github-com-gogo-protobuf)
+       ("golang-github-com-audriusbutkevicius-pfilter"
+        ,golang-github-com-audriusbutkevicius-pfilter)
+       ("github-com-ccding-go-stun"
+        ,golang-github-com-ccding-go-stun)
+       ("github-com-chmduquesne-rollinghash-adler32"
+        ,golang-github-com-chmduquesne-rollinghash-adler32)
+       ("golang-github-com-xtaci-kcp-go" ,golang-github-com-xtaci-kcp-go)
+       ("golang-github-com-klauspost-reedsolomon"
+        ,golang-github-com-klauspost-reedsolomon)
+       ("golang-github-com-xtaci-smux" ,golang-github-com-xtaci-smux)
+       ("golang-org-x-time-rate" ,golang-org-x-time-rate)
+       ("golang-github-com-oschwald-maxminddb-golang"
+        ,golang-github-com-oschwald-maxminddb-golang)
+       ("golang-org-x-sys-unix" ,golang-org-x-sys-unix)
+       ("golang-github-com-audriusbutkevicius-cli"
+        ,golang-github-com-audriusbutkevicius-cli)
+       ("golang-github-com-lib-pq" ,golang-github-com-lib-pq)
+       ("golang-github-com-oschwald-geoip2-golang"
+        ,golang-github-com-oschwald-geoip2-golang)
+       ("golang-github-com-golang-groupcache-lru"
+        ,golang-github-com-golang-groupcache-lru)
+;       ("golang-github-com-cznic-ql" ,golang-github-com-cznic-ql) ; bundled
+       ("golang-github-com-edsrzf-mmap-go" ,golang-github-com-edsrzf-mmap-go)
+       ; Tests
+       ("golang-github-com-d4l3k-messagediff"
+        ,golang-github-com-d4l3k-messagediff)))
+    (synopsis "Decentralized continuous filesystem synchronization")
+    (description "Syncthing is a peer-to-peer file synchronization tool that
+supports a wide variety of computing platforms.  It uses the Block Exchange
+Protocol.")
+    (home-page "https://github.com/syncthing/syncthing")
+    (license mpl2.0)))
+
+(define-public golang-github-com-audriusbutkevicius-go-nat-pmp
+  (let ((commit "452c97607362b2ab5a7839b8d1704f0396b640ca")
+        (revision "0"))
+    (package
+      (name "golang-github-com-audriusbutkevicius-go-nat-pmp")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/AudriusButkevicius/go-nat-pmp")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32 "1accmpl1llk16a19nlyy991fqrgfay6l53gb64hgmdfmqljdvbk7"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/AudriusButkevicius/go-nat-pmp"))
+      (synopsis "Port mapping and discovery of the external IP address")
+      (description "Go client for the NAT-PMP internet protocol for port mapping and discovering the external IP address of a firewall")
+      (home-page "https://github.com/AudriusButkevicius/go-nat-pmp")
+      (license asl2.0))))
+
+(define-public golang-github-com-bkaradzic-go-lz4
+  (let ((commit "7224d8d8f27ef618c0a95f1ae69dbb0488abc33a")
+        (revision "0"))
+    (package
+      (name "golang-github-com-bkaradzic-go-lz4")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                       (url "https://github.com/bkaradzic/go-lz4")
+                       (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                  (base32
+                    "10lmya17vdqg2pvqni0p73iahni48s1v11ya9a0hcz4jh5vw4dkb"))))
+      (build-system go-build-system)
+      (arguments
+        `(#:import-path "github.com/bkaradzic/go-lz4"))
+      (synopsis "Port of LZ4 lossless compression algorithm")
+      (description "go-lz4 is port of LZ4 lossless compression algorithm to Go")
+      (home-page "https://github.com/bkaradzic/go-lz4")
+      (license bsd-2))))
+
+(define-public golang-github-com-calmh-du
+  (package
+    (name "golang-github-com-calmh-du")
+    (version "1.0.1")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/calmh/du")
+                    (commit (string-append "v" version))))
+              (file-name (string-append name "-" version "-checkout"))
+              (sha256
+               (base32
+                "0qb3a6y3p9nkyn3s66k6zcm16y8n8578qh23ddj14cxf2scrr2n2"))))
+    (build-system go-build-system)
+    (arguments
+     `(#:import-path "github.com/calmh/du"))
+    (synopsis "Get total and available disk space on a given volume")
+    (description "Du provides disk usage information, such as how much storage
+space is available, free, and used.")
+    (home-page "https://github.com/calmh/du")
+    (license public-domain)))
+
+(define-public golang-github-com-calmh-luhn
+  (package
+    (name "golang-github-com-calmh-luhn")
+    (version "1.0.0")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/calmh/luhn")
+                    (commit (string-append "v" version))))
+              (file-name (string-append name "-" version "-checkout"))
+              (sha256
+               (base32 "1hfj1lx7wdpifn16zqrl4xml6cj5gxbn6hfz1f46g2a6bdf0gcvs"))))
+    (build-system go-build-system)
+    (arguments
+     `(#:import-path "github.com/calmh/luhn"))
+    (synopsis "Luhn-mod-N implementation in Go")
+    (description "This packages provides a Luhn-mod-N implementation in Go.")
+    (home-page "https://github.com/calmh/luhn")
+    (license expat)))
+
+(define-public golang-github-com-calmh-xdr
+  (let ((commit "08e072f9cb164f943a92eb59f90f3abc64ac6e8f")
+        (revision "0"))
+    (package
+      (name "golang-github-com-calmh-xdr")
+      (version (string-append "2.0.1-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/calmh/xdr")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "072wqdncz3nd4a3zkhvzzx1y3in1lm29wfvl0d8wrnqs5pyqh0mh"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/calmh/xdr"))
+      (synopsis "XDR marshalling and unmarshalling")
+      (description "XDR is an External Data Representation (XDR)
+marshalling and unmarshalling library in Go. It uses code generation and not
+reflection")
+      (home-page "https://github.com/calmh/xdr")
+      (license expat))))
+
+(define-public golang-github-com-d4l3k-messagediff
+  (let ((commit "29f32d820d112dbd66e58492a6ffb7cc3106312b")
+        (revision "0"))
+    (package
+      (name "golang-github-com-d4l3k-messagediff")
+      (version (string-append "1.1.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                       (url "https://github.com/d4l3k/messagediff")
+                       (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "104hl8x57ciaz7mzafg1vp9qggxcyfm8hsv9bmlihbz9ml3nyr8v"))))
+      (build-system go-build-system)
+      (arguments
+        `(#:import-path "github.com/d4l3k/messagediff"))
+      (synopsis "Diff arbitrary Golang structs")
+      (description "Messagediff is a library for calculating diffs of arbitrary
+Golang structs.")
+      (home-page "https://github.com/d4l3k/messagediff")
+      (license expat))))
+
+(define-public golang-github-com-edsrzf-mmap-go
+  (let ((commit "0bce6a6887123b67a60366d2c9fe2dfb74289d2e")
+        (revision "0"))
+    (package
+      (name "golang-github-com-edsrzf-mmap-go")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/edsrzf/mmap-go")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "1am4m2k451bksnbiqj6lxknk4lsgmrhv0q3ajqac818vj0cpfgs9"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/edsrzf/mmap-go"))
+      (synopsis "Go implementation of mmap")
+      (description "This packages provides a Go implementation of mmap.")
+      (home-page "https://github.com/edsrzf/mmap-go")
+      (license bsd-3))))
+
+(define-public golang-github-com-gobwas-glob
+  (let ((commit "51eb1ee00b6d931c66d229ceeb7c31b985563420")
+        (revision "0"))
+    (package
+      (name "golang-github-com-gobwas-glob")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                       (url "https://github.com/gobwas/glob")
+                       (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "090wzpwsjana1qas8ipwh1pj959gvc4b7vwybzi01f3bmd79jwlp"))))
+      (build-system go-build-system)
+      (arguments
+        `(#:import-path "github.com/gobwas/glob"))
+      (synopsis "Go globbing library")
+      (description "This packages provides a Go implementation of globs.")
+      (home-page "https://github.com/gobwas/glob")
+      (license expat))))
+
+(define-public golang-github-com-gogo-protobuf
+  (let ((commit "efccd33a0c20aa078705571d5ddbfa14c8395a63")
+        (revision "0"))
+    (package
+      (name "golang-github-com-gogo-protobuf")
+      (version (string-append "0.2-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/gogo/protobuf")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "09kfa3aqmhh7p0rc6wd4fw5cjccidsk9vgcy13albv0g8vnbmmgw"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/gogo/protobuf/proto"
+         #:unpack-path "github.com/gogo/protobuf"))
+      (inputs
+       `(("golang-github-com-gogo-protobuf-protoc-gen-gogo"
+          ,golang-github-com-gogo-protobuf-protoc-gen-gogo)))
+      (synopsis "Protocol Buffers for Go with Gadgets")
+      (description "gogoprotobuf is a fork of golang/protobuf with extra code
+generation features.  This code generation is used to achieve:
+
+    fast marshalling and unmarshalling
+    more canonical Go structures
+    goprotobuf compatibility
+    less typing by optionally generating extra helper code
+    peace of mind by optionally generating test and benchmark code
+    other serialization formats")
+      (home-page "https://github.com/gogo/protobuf")
+      (license bsd-3))))
+
+(define-public golang-github-com-gogo-protobuf-protoc-gen-gogo
+  (let ((commit "efccd33a0c20aa078705571d5ddbfa14c8395a63")
+        (revision "0"))
+    (package
+      (name "golang-github-com-gogo-protobuf-protoc-gen-gogo")
+      (version (string-append "0.2-" revision "0" (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/gogo/protobuf")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "09kfa3aqmhh7p0rc6wd4fw5cjccidsk9vgcy13albv0g8vnbmmgw"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/gogo/protobuf/protoc-gen-gogo"
+         #:unpack-path "github.com/gogo/protobuf"))
+      (synopsis "Protocol Buffers for Go with Gadgets")
+      (description "Gogoprotobuf is a fork of golang/protobuf with extra code
+generation features. This code generation is used to achieve:
+
+    fast marshalling and unmarshalling
+    more canonical Go structures
+    goprotobuf compatibility
+    less typing by optionally generating extra helper code
+    peace of mind by optionally generating test and benchmark code
+    other serialization formats")
+      (home-page "https://github.com/gogo/protobuf")
+      (license bsd-3))))
+
+(define-public golang-github-com-golang-groupcache-lru
+  (let ((commit "72d04f9fcdec7d3821820cc4a6f150eae553639a")
+        (revision "0"))
+    (package
+      (name "golang-github-com-golang-groupcache-lru")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/golang/groupcache")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "1l3ryh7bq1f2mhr3sd3x1wav99pd27r8l3ydgqh375wn4x7v5qd6"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/golang/groupcache/lru"
+         #:unpack-path "github.com/golang/groupcache"))
+      (synopsis "groupcache is a caching and cache-filling library")
+      (description "Groupcache is a caching and cache-filling library, intended
+as a replacement for memcached in many cases.")
+      (home-page "https://github.com/golang/groupcache")
+      (license asl2.0))))
+
+(define-public golang-github-com-golang-snappy
+  (let ((commit "553a641470496b2327abcac10b36396bd98e45c9")
+        (revision "0"))
+    (package
+      (name "golang-github-com-golang-snappy")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/golang/snappy")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "0kssxnih1l722hx9219c7javganjqkqhvl3i0hp0hif6xm6chvqk"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/golang/snappy"))
+      (synopsis "Snappy compression format in the Go programming language")
+      (description "This package provides a Go implementation of the Snappy
+compression format.")
+      (home-page "https://github.com/golang/snappy")
+      (license bsd-3))))
+
+(define-public golang-github-com-jackpal-gateway
+  (let ((commit "5795ac81146e01d3fab7bcf21c043c3d6a32b006")
+        (revision "0"))
+    (package
+      (name "golang-github-com-jackpal-gateway")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/jackpal/gateway")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "0fkwkwmhfadwk3cha8616bhqxfkr9gjjnynhhxyldlphixgs3f25"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/jackpal/gateway"))
+      (synopsis "Library for discovering the address of a LAN gateway")
+      (description "Library for discovering the address of a LAN gateway")
+      (home-page "https://github.com/jackpal/gateway")
+      (license bsd-3))))
+
+(define-public golang-github-com-kardianos-osext
+  (let ((commit "9d302b58e975387d0b4d9be876622c86cefe64be")
+        (revision "0"))
+    (package
+      (name "golang-github-com-kardianos-osext")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/kardianos/osext")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "0r6f727s16g4f66k8c2z1xh8ga1p53hg9g2v95pmhd1i60fhy47a"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/kardianos/osext"))
+      (synopsis "Find the running executable")
+      (description "Osext provides a method for finding the current executable
+file that is running.  This can be used for upgrading the current executable or
+finding resources located relative to the executable file.")
+      (home-page "https://github.com/kardianos/osext")
+      (license bsd-3))))
+
+(define-public golang-github-com-lib-pq
+  (let ((commit "2704adc878c21e1329f46f6e56a1c387d788ff94")
+        (revision "0"))
+    (package
+      (name "golang-github-com-lib-pq")
+      (version (string-append "0.0.0" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/lib/pq")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "160fmvi7bczxw3i3h5s821hv029ph5ld8x3c36b4cz2sr30wp110"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/lib/pq"
+         #:tests? #f
+         ))
+      (synopsis "Golang Postgres driver for Go's database/sql")
+      (description "This packages provides a pure Go Postgres driver for Go's
+database/sql package.")
+      (home-page "https://github.com/lib/pq")
+      (license expat))))
+
+(define-public golang-github-com-minio-sha256-simd
+  (let ((commit "6124d070eb4e7001c244b6ccc282620a5dce44a0")
+        (revision "0"))
+    (package
+      (name "golang-github-com-minio-sha256-simd")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/minio/sha256-simd")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "1azrdp7x7vl9ngkxs890blspz0345xhadvssdlb0435hdqa0gkll"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/minio/sha256-simd"))
+      (synopsis "Hardware-accelerated SHA256 in Go using SIMD")
+      (description "This packages provides a pure Go implementation of SHA256
+using SIMD instructions for Intel and ARM architectures.")
+      (home-page "https://github.com/minio/sha256-simd")
+      (license asl2.0))))
+
+(define-public golang-github-com-onsi-ginkgo
+  (let ((commit "77a8c1e5c40d6bb6c5eb4dd4bdce9763564f6298")
+        (revision "0"))
+    (package
+      (name "golang-github-com-onsi-ginkgo")
+      (version (string-append "1.2.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/onsi/ginkgo")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "12x81s3l6l4f9v5hh7rrykw18gpmwfq0dpbb6d80jyg1pffgprss"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/onsi/ginkgo"))
+      (synopsis "BDD Testing Framework for Go")
+      (description "This package provides a behavior-driven development (BDD)
+testing framework in Go.")
+      (home-page "https://github.com/onsi/ginkgo")
+      (license expat))))
+
+(define-public golang-github-com-onsi-gomega
+  (let ((commit "c893efa28eb45626cdaa76c9f653b62488858837")
+        (revision "0"))
+    (package
+      (name "golang-github-com-onsi-gomega")
+      (version (string-append "1.2.0"))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/onsi/gomega")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "1l5m7kjpdaw6q443nzn38lqb7m0yl77yfgyqrgi9i9zm01zwpvv0"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/onsi/gomega"))
+      (synopsis "Matching and assertion library in Go")
+      (description "Gomega is a matcher/assertion library.  It is best paired
+with the Ginkgo BDD test framework, but can be adapted for use in other contexts
+too.")
+      (home-page "https://github.com/onsi/gomega")
+      (license expat))))
+
+(define-public golang-github-com-oschwald-geoip2-golang
+  (let ((commit "0fd242da7906550802871efe101abfdb1cc550a8")
+        (revision "0"))
+    (package
+      (name "golang-github-com-oschwald-geoip2-golang")
+      (version (string-append "0.1.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/oschwald/geoip2-golang")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "0kglnix0r5sjkk346ip30l7dwq1gv2g4wjy2cjmgjvb8x778hnww"))))
+      (build-system go-build-system)
+      (inputs
+       `(("golang-github-com-oschwald-maxminddb-golang" ,golang-github-com-oschwald-maxminddb-golang)
+         ("golang-org-x-sys-unix" ,golang-org-x-sys-unix)))
+      (arguments
+       `(#:import-path "github.com/oschwald/geoip2-golang"
+         #:tests? #f)) ; Requires some unpackaged software
+      (synopsis "MaxMind GeoIP2 reader")
+      (description "This packages provides a library for reading MaxMind
+GeoLite2 and GeoIP2 databases in Go.")
+      (home-page "https://github.com/oschwald/geoip2-golang")
+      (license isc))))
+
+(define-public golang-github-com-oschwald-maxminddb-golang
+  (let ((commit "697da8075d2061aa8ed639346443f5d3e8c80b30")
+        (revision "0"))
+    (package
+      (name "golang-github-com-oschwald-maxminddb-golang")
+      (version (string-append "0.2.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/oschwald/maxminddb-golang")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "00kkxzlvra0kcbkl56wp0dp1yw3cmfjqqlwbqy7bq5r34s7iavq0"))))
+      (build-system go-build-system)
+      (inputs
+       `(("golang-org-x-sys-unix" ,golang-org-x-sys-unix)))
+      (arguments
+       `(#:import-path "github.com/oschwald/maxminddb-golang"
+         #:tests? #f)) ; Requires some unpackaged software
+      (synopsis "MaxMind DB Reader for Go")
+      (description "This is a Go reader for the MaxMind DB format.  Although
+this can be used to read GeoLite2 and GeoIP2 databases, geoip2 provides a
+higher-level API for doing so.")
+      (home-page "https://github.com/oschwald/maxminddb-golang")
+      (license isc))))
+
+(define-public golang-github-com-rcrowley-go-metrics
+  (let ((commit "1f30fe9094a513ce4c700b9a54458bbb0c96996c")
+        (revision "0"))
+    (package
+      (name "golang-github-com-rcrowley-go-metrics")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/rcrowley/go-metrics")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "1hvbiaq4b6dqgjz6jkkxglfh9gf71zin6qsg508sh0r0ixfavrzj"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/rcrowley/go-metrics"))
+      (synopsis "Go port of Coda Hale's Metrics library")
+      (description "This package provides a Go port of Coda Hale's Metrics
+library.")
+      (home-page "https://github.com/rcrowley/go-metrics")
+      (license bsd-2))))
+
+(define-public golang-github-com-sasha-s-go-deadlock
+  (package
+    (name "golang-github-com-sasha-s-go-deadlock")
+    (version "341000892f3dd25f440e6231e8533eb3688ed7ec")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/sasha-s/go-deadlock")
+                    (commit version)))
+              (file-name (string-append name "-" version "-checkout"))
+              (sha256
+               (base32
+                "1bcdyxwm5qpqynxahwaahbqi7ghgdajmg7b4276pdalkxkxkhsv8"))))
+    (build-system go-build-system)
+    (arguments
+     `(#:import-path "github.com/sasha-s/go-deadlock"))
+    (propagated-inputs
+     `(("golang-github-com-petermattis-goid" ,golang-github-com-petermattis-goid)))
+    (synopsis "Deadlock detection in go")
+    (description "This package provides tools for detecting deadlocks at
+run-time in Go.")
+    (home-page "https://github.com/sasha-s/go-deadlock")
+    (license asl2.0)))
+
+(define-public golang-github-com-stathat-go
+  (let ((commit "74669b9f388d9d788c97399a0824adbfee78400e")
+        (revision "0"))
+    (package
+      (name "golang-github-com-stathat-go")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/stathat/go")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32 "105ql5v8r4hqcsq0ag7asdxqg9n7rvf83y1q1dj2nfjyn4manv6r"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/stathat/go"))
+      (synopsis "Post statistics to StatHat")
+      (description "This is a Go package for posting to a StatHat account.")
+      (home-page "https://github.com/stathat/go")
+      (license expat))))
+
+(define-public golang-github-com-syndtr-goleveldb
+  (let ((commit "3c5717caf1475fd25964109a0fc640bd150fce43")
+        (revision "0"))
+    (package
+      (name "golang-github-com-syndtr-goleveldb")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/syndtr/goleveldb")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "0wng25bw885ppiny9rz42kq0a7ddkym5zl0glb8rfk0m8dpvi1dd"))))
+      (build-system go-build-system)
+      (inputs
+       `(("github.com-golang-snappy" ,golang-github-com-golang-snappy)))
+      (arguments
+       `(#:import-path "github.com/syndtr/goleveldb/leveldb"
+         #:unpack-path "github.com/syndtr/goleveldb"
+         #:tests? #f)) ; XXX needs gomega package
+      (synopsis "LevelDB key/value database")
+      (description "This is an implementation of the LevelDB key / value
+database in Go.")
+      (home-page "https://github.com/syndtr/goleveldb")
+      (license bsd-2))))
+
+(define-public golang-github-com-thejerf-suture
+  (let ((commit "0ac47afae95ad5bc5184ed346bc945168e883f5d")
+        (revision "0"))
+    (package
+      (name "golang-github-com-thejerf-suture")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/thejerf/suture")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "0f860fkaibnnkmh4q6q9yn3r26sraaj8wx9irwm76cmsp48zcxfy"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/thejerf/suture"))
+      (synopsis "Supervisor trees for Go")
+      (description "Suture provides Erlang-ish supervisor trees for Go.
+\"Supervisor trees\" -> \"sutree\" -> \"suture\" -> holds your code together
+when it's trying to die.
+
+It is intended to deal gracefully with the real failure cases that can occur
+with supervision trees (such as burning all your CPU time endlessly restarting
+dead services), while also making no unnecessary demands on the \"service\"
+code, and providing hooks to perform adequate logging with in a production
+environment")
+      (home-page "https://github.com/thejerf/suture")
+      (license expat))))
+
+(define* (golang-github-com-vitrun-qart
+           #:optional (packages (list golang-github-com-vitrun-qart-coding
+                                      golang-github-com-vitrun-qart-gf256
+                                      golang-github-com-vitrun-qart-qr)))
+  (package
+    (name "golang-github-com-vitrun-qart")
+    (version (package-version golang-github-com-vitrun-qart-coding))
+    (source #f)
+    (build-system trivial-build-system)
+    (arguments
+     '(#:modules ((guix build union))
+       #:builder (begin
+                   (use-modules (ice-9 match)
+                                (guix build union))
+                   (match %build-inputs
+                     (((names . directories) ...)
+                      (union-build (assoc-ref %outputs "out")
+                                   directories))))))
+    (inputs (map (lambda (package)
+                   (list (package-name package) package))
+                 packages))
+    (synopsis "Union of qart libraries")
+    (description "This is a union of qart libraries.")
+    (home-page (package-home-page golang-github-com-vitrun-qart-coding))
+    (license (package-license golang-github-com-vitrun-qart-coding))))
+
+(define-public golang-github-com-vitrun-qart-coding
+  (let ((commit "bf64b92db6b05651d6c25a3dabf2d543b360c0aa")
+        (revision "0"))
+    (package
+      (name "golang-github-com-vitrun-qart-coding")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/vitrun/qart")
+                      (commit commit)))
+                (file-name (string-append "golang-github-com-vitrun-qart-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1xk7qki703xmay9ghi3kq2bjf1iw9dz8wik55739d6i7sn77vvkc"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/vitrun/qart/coding"
+         #:unpack-path "github.com/vitrun/qart"))
+      (synopsis "Package coding implements low-level QR coding details")
+      (description "Instead of scribbling on redundant pieces and relying on
+error correction to preserve the meaning, qart engineers the encoded values to
+create the picture in a code with no inherent errors. Package coding implements
+low-level QR coding details")
+      (home-page "https://github.com/vitrun/qart/")
+      (license bsd-3))))
+
+(define-public golang-github-com-vitrun-qart-gf256
+  (let ((commit "bf64b92db6b05651d6c25a3dabf2d543b360c0aa")
+        (revision "0"))
+    (package
+      (name "golang-github-com-vitrun-qart-gf256")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/vitrun/qart")
+                      (commit commit)))
+                (file-name (string-append "golang-github-com-vitrun-qart-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1xk7qki703xmay9ghi3kq2bjf1iw9dz8wik55739d6i7sn77vvkc"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/vitrun/qart/gf256"
+         #:unpack-path "github.com/vitrun/qart"))
+      (synopsis "Package gf256 implements arithmetic over the Galois Field GF(256)")
+      (description "Instead of scribbling on redundant pieces and relying on
+error correction to preserve the meaning, qart engineers the encoded values to
+create the picture in a code with no inherent errors. Package gf256 implements
+arithmetic over the Galois Field GF(256)")
+      (home-page "https://github.com/vitrun/qart")
+      (license bsd-3))))
+
+(define-public golang-github-com-vitrun-qart-qr
+  (let ((commit "bf64b92db6b05651d6c25a3dabf2d543b360c0aa")
+        (revision "0"))
+    (package
+      (name "golang-github-com-vitrun-qart-qr")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/vitrun/qart")
+                      (commit commit)))
+                (file-name (string-append "golang-github-com-vitrun-qart-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1xk7qki703xmay9ghi3kq2bjf1iw9dz8wik55739d6i7sn77vvkc"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/vitrun/qart/qr"
+         #:unpack-path "github.com/vitrun/qart"))
+      (synopsis "Qart generates not-so-ugly qr codes")
+      (description "Instead of scribbling on redundant pieces and relying on
+error correction to preserve the meaning, qart engineers the encoded values to
+create the picture in a code with no inherent errors.")
+      (home-page "https://github.com/vitrun/qart")
+      (license bsd-3))))
+
+;; Go searches for library modules by looking in the GOPATH environment
+;; variable.  This variable is a list of paths.  However, Go does not
+;; keep searching on GOPATH if it tries and fails to import a module.
+;; So, we use a union for packages sharing a namespace.
+(define* (golang-org-x-crypto #:optional
+                              (packages (list golang-org-x-crypto-blowfish
+                                              golang-org-x-crypto-bcrypt
+                                              golang-org-x-crypto-tea
+                                              golang-org-x-crypto-xtea
+                                              golang-org-x-crypto-pbkdf2
+                                              golang-org-x-crypto-twofish
+                                              golang-org-x-crypto-cast5
+                                              golang-org-x-crypto-salsa20)))
+  (package
+    (name "golang-org-x-crypto")
+    (version (package-version golang-org-x-crypto-bcrypt))
+    (source #f)
+    (build-system trivial-build-system)
+    (arguments
+     '(#:modules ((guix build union))
+       #:builder (begin
+                   (use-modules (ice-9 match)
+                                (guix build union))
+                   (match %build-inputs
+                     (((names . directories) ...)
+                      (union-build (assoc-ref %outputs "out")
+                                   directories))))))
+    (inputs (map (lambda (package)
+                   (list (package-name package) package))
+                 packages))
+    (synopsis "Union of the Go x crypto libraries")
+    (description "A union of the Golang cryptographic libraries.  A
+union is required because `go build` assumes that all of the headers and
+libraries are in the same directory.")
+    (home-page (package-home-page golang-org-x-crypto-bcrypt))
+    (license (package-license golang-org-x-crypto-bcrypt))))
+
+(define-public golang-org-x-crypto-bcrypt
+  (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd")
+        (revision "0"))
+    (package
+      (name "golang-org-x-crypto-bcrypt")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/crypto")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-crypto-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/crypto/bcrypt"
+         #:unpack-path "golang.org/x/crypto"
+         #:phases
+         (modify-phases %standard-phases
+           (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable
+             (lambda* (#:key outputs #:allow-other-keys)
+               (map (lambda (file)
+                      (make-file-writable file))
+                    (find-files
+                      (string-append (assoc-ref outputs "out")
+                                     "/src/golang.org/x/crypto/ed25519/testdata")
+                      ".*\\.gz$"))
+               #t)))))
+      (synopsis "Bcrypt in Go")
+      (description "This package provides a Go implementation of bcrypt.")
+      (home-page "https://go.googlesource.com/crypto/")
+      (license bsd-3))))
+
+(define-public golang-org-x-crypto-blowfish
+  (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd")
+        (revision "0"))
+    (package
+      (name "golang-org-x-crypto-blowfish")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/crypto")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-crypto-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/crypto/blowfish"
+         #:unpack-path "golang.org/x/crypto"
+         #:phases
+         (modify-phases %standard-phases
+           (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable
+             (lambda* (#:key outputs #:allow-other-keys)
+               (map (lambda (file)
+                      (make-file-writable file))
+                    (find-files
+                      (string-append (assoc-ref outputs "out")
+                                     "/src/golang.org/x/crypto/ed25519/testdata")
+                      ".*\\.gz$"))
+               #t)))))
+      (synopsis "Blowfish in Go")
+      (description "This package provides a Go implementation of Blowfish.")
+      (home-page "https://go.googlesource.com/crypto/")
+      (license bsd-3))))
+
+(define-public golang-org-x-crypto-pbkdf2
+  (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd")
+        (revision "0"))
+    (package
+      (name "golang-org-x-crypto-pbkdf2")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/crypto")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-crypto-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/crypto/pbkdf2"
+         #:unpack-path "golang.org/x/crypto"
+         #:phases
+         (modify-phases %standard-phases
+           (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable
+             (lambda* (#:key outputs #:allow-other-keys)
+               (map (lambda (file)
+                      (make-file-writable file))
+                    (find-files
+                      (string-append (assoc-ref outputs "out")
+                                     "/src/golang.org/x/crypto/ed25519/testdata")
+                      ".*\\.gz$"))
+               #t)))))
+      (synopsis "Pbkdf2 in Go")
+      (description "This package provides a Go implementation of pbkdf2.")
+      (home-page "https://go.googlesource.com/crypto/")
+      (license bsd-3))))
+
+(define-public golang-org-x-crypto-tea
+  (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd")
+        (revision "0"))
+    (package
+      (name "golang-org-x-crypto-tea")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/crypto")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-crypto-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/crypto/tea"
+         #:unpack-path "golang.org/x/crypto"
+         #:phases
+         (modify-phases %standard-phases
+           (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable
+             (lambda* (#:key outputs #:allow-other-keys)
+               (map (lambda (file)
+                      (make-file-writable file))
+                    (find-files
+                      (string-append (assoc-ref outputs "out")
+                                     "/src/golang.org/x/crypto/ed25519/testdata")
+                      ".*\\.gz$"))
+               #t)))))
+      (synopsis "Tiny Encryption Algorithm (TEA) in Go")
+      (description "This packages a Go implementation of the Tiny Encryption
+Algorithm (TEA).")
+      (home-page "https://go.googlesource.com/crypto/")
+      (license bsd-3))))
+
+(define-public golang-org-x-crypto-salsa20
+  (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd")
+        (revision "0"))
+    (package
+      (name "golang-org-x-crypto-salsa20")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/crypto")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-crypto-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/crypto/salsa20"
+         #:unpack-path "golang.org/x/crypto"
+         #:phases
+         (modify-phases %standard-phases
+           (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable
+             (lambda* (#:key outputs #:allow-other-keys)
+               (map (lambda (file)
+                      (make-file-writable file))
+                    (find-files
+                      (string-append (assoc-ref outputs "out")
+                                     "/src/golang.org/x/crypto/ed25519/testdata")
+                      ".*\\.gz$"))
+               #t)))))
+      (synopsis "Salsa20 in Go")
+      (description "This packages provides a Go implementation of Salsa20.")
+      (home-page "https://go.googlesource.com/crypto/")
+      (license bsd-3))))
+
+(define-public golang-org-x-crypto-cast5
+  (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd")
+        (revision "0"))
+    (package
+      (name "golang-org-x-crypto-cast5")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/crypto")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-crypto-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/crypto/cast5"
+         #:unpack-path "golang.org/x/crypto"
+         #:phases
+         (modify-phases %standard-phases
+           (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable
+             (lambda* (#:key outputs #:allow-other-keys)
+               (map (lambda (file)
+                      (make-file-writable file))
+                    (find-files
+                      (string-append (assoc-ref outputs "out")
+                                     "/src/golang.org/x/crypto/ed25519/testdata")
+                      ".*\\.gz$"))
+               #t)))))
+      (synopsis "Cast5 in Go")
+      (description "This packages provides a Go implementation of Cast5.")
+      (home-page "https://go.googlesource.com/crypto/")
+      (license bsd-3))))
+
+(define-public golang-org-x-crypto-twofish
+  (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd")
+        (revision "0"))
+    (package
+      (name "golang-org-x-crypto-twofish")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/crypto")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-crypto-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/crypto/twofish"
+         #:unpack-path "golang.org/x/crypto"
+         #:phases
+         (modify-phases %standard-phases
+           (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable
+             (lambda* (#:key outputs #:allow-other-keys)
+               (map (lambda (file)
+                      (make-file-writable file))
+                    (find-files
+                      (string-append (assoc-ref outputs "out")
+                                     "/src/golang.org/x/crypto/ed25519/testdata")
+                      ".*\\.gz$"))
+               #t)))))
+      (synopsis "Twofish in Go")
+      (description "This packages provides a Go implementation of Twofish.")
+      (home-page "https://go.googlesource.com/crypto/")
+      (license bsd-3))))
+
+(define-public golang-org-x-crypto-xtea
+  (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd")
+        (revision "0"))
+    (package
+      (name "golang-org-x-crypto-xtea")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/crypto")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-crypto-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/crypto/xtea"
+         #:unpack-path "golang.org/x/crypto"
+         #:phases
+         (modify-phases %standard-phases
+           (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable
+             (lambda* (#:key outputs #:allow-other-keys)
+               (map (lambda (file)
+                      (make-file-writable file))
+                    (find-files
+                      (string-append (assoc-ref outputs "out")
+                                     "/src/golang.org/x/crypto/ed25519/testdata")
+                      ".*\\.gz$"))
+               #t)))))
+      (synopsis "eXtended Tiny Encryption Algorithm (XTEA) in Go")
+      (description "This package provides a Go implementation of the eXtended
+Tiny Encryption Algorithm (XTEA).")
+      (home-page "https://go.googlesource.com/crypto/")
+      (license bsd-3))))
+
+(define-public golang-org-x-net-html-charset
+  (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d")
+        (revision "0"))
+    (package
+      (name "golang-org-x-net-html-charset")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/net")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-net-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/net/html/charset"
+         #:unpack-path "golang.org/x/net"))
+      (inputs
+       `(("golang-org-x-text-encoding" ,golang-org-x-text-encoding)))
+      (synopsis "Golang HTML encoding")
+      (description "This packages provides @code{charset}, which provides common
+text encodings for HTML documents.")
+      (home-page "https://go.googlesource.com/net/")
+      (license bsd-3))))
+
+(define-public golang-org-x-net-bpf
+  (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d")
+        (revision "0"))
+    (package
+      (name "golang-org-x-net-bpf")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/net")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-net-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/net/bpf"
+         #:unpack-path "golang.org/x/net"))
+      (synopsis "Berkeley Packet Filters (BPF) in Go")
+      (description "This packages provides a Go implementation of the Berkeley
+Packet Filter (BPF) virtual machine.")
+      (home-page "https://go.googlesource.com/net/")
+      (license bsd-3))))
+
+(define-public golang-org-x-net-context
+  (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d")
+        (revision "0"))
+    (package
+      (name "golang-org-x-net-context")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/net")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-net-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/net/context"
+         #:unpack-path "golang.org/x/net"))
+      (synopsis "Golang Context type")
+      (description "This packages provides @code{context}, which defines the
+Context type, which carries deadlines, cancelation signals, and other
+request-scoped values across API boundaries and between processes.")
+      (home-page "https://go.googlesource.com/net/")
+      (license bsd-3))))
+
+(define-public golang-org-x-net-internal-iana
+  (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d")
+        (revision "0"))
+    (package
+      (name "golang-org-x-net-internal-iana")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/net")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-net-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/net/internal/iana"
+         #:unpack-path "golang.org/x/net"))
+      (synopsis "Go support for assigned numbers (IANA)")
+      (description "This packages provides @code{iana}, which provides protocol
+number resources managed by the Internet Assigned Numbers Authority (IANA).")
+      (home-page "https://go.googlesource.com/net/")
+      (license bsd-3))))
+
+(define-public golang-org-x-net-ipv6
+  (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d")
+        (revision "0"))
+    (package
+      (name "golang-org-x-net-ipv6")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/net")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-net-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/net/ipv6"
+         #:unpack-path "golang.org/x/net"))
+      (synopsis "Go IPv6 support")
+      (description "This packages provides @code{ipv6}, which implements
+IP-level socket options for the Internet Protocol version 6.")
+      (home-page "https://go.googlesource.com/net")
+      (license bsd-3))))
+
+(define-public golang-org-x-net-proxy
+  (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d")
+        (revision "0"))
+    (package
+      (name "golang-org-x-net-proxy")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/net")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-net-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/net/proxy"
+         #:unpack-path "golang.org/x/net/"))
+      (synopsis "Go support for network proxies")
+      (description "This packages provides @code{proxy}, which provides support
+for a variety of protocols to proxy network data.")
+      (home-page "https://go.googlesource.com/net")
+      (license bsd-3))))
+
+(define-public golang-org-x-sys-unix
+  (let ((commit "f3918c30c5c2cb527c0b071a27c35120a6c0719a")
+        (revision "0"))
+    (package
+      (name "golang-org-x-sys-unix")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/sys")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "02967mw0nq7hp39bcf8rdbid4jgz2fn6hd1x03mmavvca03scxbh"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/sys/unix"
+         #:unpack-path "golang.org/x/sys"))
+      (synopsis "Go support for low-level system interaction")
+      (description "This package provides @code{unix}, which offers Go support
+for low-level interaction with the operating system.")
+      (home-page "https://go.googlesource.com/sys")
+      (license bsd-3))))
+
+(define* (golang-org-x-text #:optional
+                            (packages (list golang-org-x-text-transform
+                                            golang-org-x-text-unicode-norm)))
+  (package
+    (name "golang-org-x-text")
+    (version (package-version golang-org-x-text-transform))
+    (source #f)
+    (build-system trivial-build-system)
+    (arguments
+     '(#:modules ((guix build union))
+       #:builder (begin
+                   (use-modules (ice-9 match)
+                                (guix build union))
+                   (match %build-inputs
+                     (((names . directories) ...)
+                      (union-build (assoc-ref %outputs "out")
+                                   directories))))))
+    (inputs (map (lambda (package)
+                   (list (package-name package) package))
+                 packages))
+    (synopsis "Union of the Go text libraries")
+    (description "A union of the Golang text libraries.")
+    (home-page (package-home-page golang-org-x-text-transform))
+    (license (package-license golang-org-x-text-transform))))
+
+(define-public golang-org-x-text-transform
+  (let ((commit "f4b4367115ec2de254587813edaa901bc1c723a8")
+        (revision "0"))
+    (package
+      (name "golang-org-x-text-transform")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/text")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-text-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1a5m97y7sdxks02p4swg8ffp8bgr95aaf5fhfw511p7h3xg1dm0d"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/text/transform"
+         #:unpack-path "golang.org/x/text"))
+      (synopsis "Go text transformation")
+      (description "This package provides @code{transform}, which provides
+reader and writer wrappers that transform the bytes passing through as well as
+various transformations.  Example transformations provided by other packages
+include normalization and conversion between character sets.")
+      (home-page "https://go.googlesource.com/text")
+      (license bsd-3))))
+
+(define-public golang-org-x-text-unicode-norm
+  (let ((commit "f4b4367115ec2de254587813edaa901bc1c723a8")
+        (revision "0"))
+    (package
+      (name "golang-org-x-text-unicode-norm")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/text")
+                      (commit commit)))
+                (file-name (string-append "go.googlesource.com-text-"
+                                          version "-checkout"))
+                (sha256
+                 (base32
+                  "1a5m97y7sdxks02p4swg8ffp8bgr95aaf5fhfw511p7h3xg1dm0d"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/text/unicode/norm"
+         #:unpack-path "golang.org/x/text"))
+      (synopsis "Unicode normalization in Go")
+      (description "This package provides @code{norm}, which contains types and
+functions for normalizing Unicode strings.")
+      (home-page "https://go.googlesource.com/text")
+      (license bsd-3))))
+
+(define-public golang-github-com-audriusbutkevicius-pfilter
+  (let ((commit "09b3cfdd04de89f0196caecb0b335d7149a6593a")
+        (revision "0"))
+    (package
+      (name "golang-github-com-audriusbutkevicius-pfilter")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+        (origin
+          (method git-fetch)
+          (uri (git-reference
+                 (url "https://github.com/AudriusButkevicius/pfilter.git")
+                 (commit commit)))
+          (file-name (string-append name "-" version "-checkout"))
+          (sha256
+           (base32
+            "176g8dmi2i94bxpnpgvj3dv5y9hripi45kbrfvy2bk884hwbp1zq"))))
+      (build-system go-build-system)
+      (arguments
+       '(#:import-path "github.com/AudriusButkevicius/pfilter"))
+      (synopsis "Filter packets into mulitple virtual connections")
+      (description "Pfilter is a Go package for filtering packets into multiple
+virtual connections from a single physical connection.")
+      (home-page "https://github.com/AudriusButkevicius/pfilter")
+      (license expat))))
+
+(define-public golang-github-com-ccding-go-stun
+  (let ((commit "04a4eed61c57ecc9903f8983d1d2c17b88d2e9e1")
+        (revision "0"))
+    (package
+      (name "golang-github-com-ccding-go-stun")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+        (origin
+          (method git-fetch)
+          (uri (git-reference
+                 (url "https://github.com/ccding/go-stun.git")
+                 (commit commit)))
+          (file-name (string-append name "-" version "-checkout"))
+          (sha256
+           (base32
+            "09fgmkvm0vzinl3ifrixyyxk2c9hbahrja7i0ir400harzq3my10"))))
+      (build-system go-build-system)
+      (arguments
+       '(#:import-path "github.com/ccding/go-stun"))
+      (synopsis "STUN client implementation")
+      (description "Go-stun is a go implementation of the STUN client (RFC 3489
+and RFC 5389).")
+      (home-page "https://github.com/ccding/go-stun")
+      (license asl2.0))))
+
+(define-public golang-github-com-chmduquesne-rollinghash-adler32
+  (let ((commit "043b8fdecc9816f0011a056f6d92f9a091ab63dd")
+        (revision "0"))
+    (package
+      (name "golang-github-com-chmduquesne-rollinghash-adler32")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+        (origin
+          (method git-fetch)
+          (uri (git-reference
+                 (url "https://github.com/chmduquesne/rollinghash.git")
+                 (commit commit)))
+          (file-name (string-append name "-" version "-checkout"))
+          (sha256
+           (base32
+            "0pc87laxgydqv03bdirfv32y9k0bdk2cwjxn28yh42nvay9p6y0k"))))
+      (build-system go-build-system)
+      (arguments
+       '(#:import-path "github.com/chmduquesne/rollinghash/adler32"
+         #:unpack-path "github.com/chmduquesne/rollinghash"))
+      (synopsis "Adler-32 rolling hash in Go")
+      (description "This package provides a Go implementation of the Adler-32
+rolling hash.")
+      (home-page "https://github.com/chmduquesne/rollinghash")
+      (license expat))))
+
+(define-public golang-github-com-xtaci-kcp-go
+  (let ((commit "0b0731ef3f184a8985edcb4ca26a4b0598c6dc1a")
+        (revision "0"))
+    (package
+      (name "golang-github-com-xtaci-kcp-go")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+        (origin
+          (method git-fetch)
+          (uri (git-reference
+                 (url "https://github.com/xtaci/kcp-go.git")
+                 (commit commit)))
+          (file-name (string-append name "-" version "-checkout"))
+          (sha256
+           (base32
+            "1cjv5wj1szfqv2yhjil6ka3lzcf7vakmyvrabpblcy2vcw3k71k7"))))
+      (build-system go-build-system)
+      (inputs
+       `(("golang-org-x-net-ipv4" ,golang-org-x-net-ipv4)
+         ("golang-github-com-klauspost-reedsolomon" ,golang-github-com-klauspost-reedsolomon)
+         ("golang-github-com-klauspost-cpuid" ,golang-github-com-klauspost-cpuid)
+         ("golang-github-com-pkg-errors" ,golang-github-com-pkg-errors)
+         ("golang-org-x-crypto" ,(golang-org-x-crypto))))
+      (arguments
+       '(#:import-path "github.com/xtaci/kcp-go"
+         #:phases
+         (modify-phases %standard-phases
+           (add-after 'unpack 'disable-failing-test
+             (lambda _
+               (substitute* "src/github.com/xtaci/kcp-go/sess_test.go"
+                            (("TestParallel") "DisabledTestParallel"))
+               #t)))))
+      (synopsis "Reliable UDP connections in Go")
+      (description "kcp-go is a reliable UDP library written in Go.  It provides
+fast, ordered and error-checked delivery of streams over UDP packets.")
+      (home-page "https://github.com/xtaci/kcp-go")
+      (license expat))))
+
+(define-public golang-github-com-xtaci-smux
+  (let ((commit "0f6b9aaecaaf354357adc7def9239011ad276776")
+        (revision "0"))
+    (package
+      (name "golang-github-com-xtaci-kcp-smux")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source
+        (origin
+          (method git-fetch)
+          (uri (git-reference
+                 (url "https://github.com/xtaci/smux.git")
+                 (commit commit)))
+          (file-name (string-append name "-" version "-checkout"))
+          (sha256
+           (base32
+            "0wx9j0id2f5iqvyalhm4i80fr9k25klr7qqj8sd9acwp5vfl5fas"))))
+      (build-system go-build-system)
+      (propagated-inputs
+       `(("golang-github-com-pkg-errors" ,golang-github-com-pkg-errors)))
+      (arguments
+       '(#:import-path "github.com/xtaci/smux"))
+      (synopsis "Network multiplexing in Go")
+      (description "Smux ( Simple MUltipleXing) is a multiplexing library for
+Golang.  It relies on an underlying connection to provide reliability and
+ordering, such as TCP or KCP, and provides stream-oriented multiplexing.")
+      (home-page "https://github.com/xtaci/smux")
+      (license expat))))
+
+(define* (golang-org-x-net #:optional
+                           (packages (list golang-org-x-net-ipv4
+                                           golang-org-x-net-bpf
+                                           golang-org-x-net-context
+                                           golang-org-x-net-ipv6
+                                           golang-org-x-net-proxy
+                                           golang-org-x-net-internal-iana)))
+  (package
+    (name "golang-org-x-net")
+    (version (package-version golang-org-x-net-ipv4))
+    (source #f)
+    (build-system trivial-build-system)
+    (arguments
+     '(#:modules ((guix build union))
+       #:builder (begin
+                   (use-modules (ice-9 match)
+                                (guix build union))
+                   (match %build-inputs
+                     (((names . directories) ...)
+                      (union-build (assoc-ref %outputs "out")
+                                   directories))))))
+    (inputs (map (lambda (package)
+                   (list (package-name package) package))
+                 packages))
+    (synopsis "Union of the Go net libraries")
+    (description "A union of the Golang net libraries.")
+    (home-page (package-home-page golang-org-x-net-ipv4))
+    (license (package-license golang-org-x-net-ipv4))))
+
+(define-public golang-org-x-net-ipv4
+  (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d")
+        (revision "0"))
+    (package
+      (name "golang-org-x-net-ipv4")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/net")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/net/ipv4"
+         #:unpack-path "golang.org/x/net"))
+      (synopsis "Go IPv4 support")
+      (description "This package provides @code{ipv4}, which implements IP-level
+socket options for the Internet Protocol version 4.")
+      (home-page "https://go.googlesource.com/net")
+      (license bsd-3))))
+
+(define-public golang-github-com-klauspost-reedsolomon
+  (let ((commit "5abf0ee302ccf4834e84f63ff74eca3e8b88e4e2")
+        (revision "0"))
+    (package
+      (name "golang-github-com-klauspost-reedsolomon")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/klauspost/reedsolomon.git")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "1za3db8zc76rg2f4kpvw4x8pykbyhmacnhdhyys73421f0m50a0s"))))
+      (build-system go-build-system)
+      (propagated-inputs
+       `(("golang-github-com-klauspost-cpuid"
+          ,golang-github-com-klauspost-cpuid)))
+      (arguments
+       `(#:import-path "github.com/klauspost/reedsolomon"))
+      (synopsis "Reed-Solomon Erasure Coding in Go")
+      (description "This package provides Reed-Solomon Erasure Coding in Go.")
+      (home-page "https://github.com/klauspost/reedsolomon")
+      (license expat))))
+
+(define-public golang-github-com-klauspost-cpuid
+  (let ((commit "09cded8978dc9e80714c4d85b0322337b0a1e5e0")
+        (revision "0"))
+    (package
+      (name "golang-github-com-klauspost-cpuid")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/klauspost/cpuid.git")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "05l8pfch0gvxh0khapwxhsk4xajn40vbjr360n49vh2z5531v2xq"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/klauspost/cpuid"))
+      (synopsis "CPU feature identification for Go")
+      (description "This package provides @code{cpuid}, which provides
+information about the CPU running the current program.  CPU features are
+detected on startup, and kept for access through the life of the
+application. Currently x86 / x64 (AMD64) is supported, and no external C (cgo)
+code is used.")
+      (home-page "https://github.com/klauspost/cpuid")
+      (license expat))))
+
+(define-public golang-github-com-pkg-errors
+  (let ((commit "ff09b135c25aae272398c51a07235b90a75aa4f0")
+        (revision "0"))
+    (package
+      (name "golang-github-com-pkg-errors")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/pkg/errors.git")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "0pwl6v3hmc22zp32gkyqykl4kg69xk1mlp0vmhgd1f44difd5fvz"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "github.com/pkg/errors"))
+      (synopsis "Go error handling primitives")
+      (description "This packages provides @code{error}, which offers simple
+error handling primitives in Go.")
+      (home-page "https://github.com/pkg/errors")
+      (license bsd-2))))
+
+(define-public golang-org-x-time-rate
+  (let ((commit "f51c12702a4d776e4c1fa9b0fabab841babae631")
+        (revision "0"))
+    (package
+      (name "golang-org-x-time-rate")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://go.googlesource.com/time")
+                      (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "07wc6g2fvafkr6djsscm0jpbpl4135khhb6kpyx1953hi5d1jvyy"))))
+      (build-system go-build-system)
+      (arguments
+       `(#:import-path "golang.org/x/time/rate"
+         #:unpack-path "golang.org/x/time"))
+      (inputs
+       `(("golang-org-x-net-context" ,golang-org-x-net-context)))
+      (synopsis "Rate limiting in Go")
+      (description "This package provides @{rate}, which implements rate
+limiting in Go.")
+      (home-page "https://godoc.org/golang.org/x/time/rate")
+      (license bsd-3))))
+
+(define-public golang-github-com-petermattis-goid
+  (let ((commit "3db12ebb2a599ba4a96bea1c17b61c2f78a40e02")
+        (revision "0"))
+    (package
+      (name "golang-github-com-petermattis-goid")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                       (url "https://github.com/petermattis/goid.git")
+                       (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+
+                 (base32
+                  "0z18a3mr72c52g7g94n08gxw0ksnaafbfwdl5p5jav2sffirb0kd"))))
+      (build-system go-build-system)
+      (arguments
+       '(#:import-path "github.com/petermattis/goid"))
+      (synopsis "Identify the running goroutine")
+      (description "This package offers a method of programatically retrieving
+the current goroutine's ID.")
+      (home-page "https://github.com/petermattis/goid")
+      (license asl2.0))))
+
+(define-public golang-github-com-audriusbutkevicius-cli
+  (let ((commit "7f561c78b5a4aad858d9fd550c92b5da6d55efbb")
+        (revision "0"))
+    (package
+      (name "golang-github-com-audriusbutkevicius-cli")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                       (url "https://github.com/AudriusButkevicius/cli.git")
+                       (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "0bg26pfg25vr16jmczig2m493mja2nxjxyswz3hha7avxw20rpi5"))))
+      (build-system go-build-system)
+      (arguments
+       '(#:import-path "github.com/AudriusButkevicius/cli"))
+      (synopsis "Library for building command-line interfaces in Go")
+      (description "This package provides a library for building command-line
+interfaces in Go.")
+      (home-page "https://github.com/AudriusButkevicius/cli")
+      (license expat))))
+
+(define-public golang-github-com-kballard-go-shellquote
+  (let ((commit "cd60e84ee657ff3dc51de0b4f55dd299a3e136f2")
+        (revision "0"))
+    (package
+      (name "golang-github-com-kballard-go-shellquote")
+      (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                       (url "https://github.com/kballard/go-shellquote.git")
+                       (commit commit)))
+                (file-name (string-append name "-" version "-checkout"))
+                (sha256
+                 (base32
+                  "1xjpin4jq1zl84dcn96xhjmn9bsfyszf6g9aqyj2dc0xfi6c88y0"))))
+      (build-system go-build-system)
+      (arguments
+       '(#:import-path "github.com/kballard/go-shellquote"))
+      (synopsis "Shell-style string joins and splits")
+      (description "Shellquote provides utilities for joining/splitting strings
+using sh's word-splitting rules.")
+      (home-page "https://github.com/kballard/go-shellquote")
+      (license expat))))
-- 
2.14.1