Subject: build: Add julia-build-system
From: Nicolò Balzarotti <[email-masked]>
To: [email-masked]
Date: Tue, 30 Jul 2019 12:49:43 +0000
List-Id: <debbugs-submit.debbugs.gnu.org>

Hello people! :)

Lately I've been working a bit on julia packages support in guix.

The good news first: I've been able to install dozen of them, including
those depending on binaryprovider with simple workarounds.
1. By writing manually the deps.jl file (the one that saves the path of
dynamic libraries in a julia const)
2. By "manually" writing required Package.toml files for old packages that
are not using it yet (else julia cannot find them)
3. By adding a simple startup.jl script, inspired by what emacs does. This
is simplified so I'm not sure it works for every corner case.
#+begin_src julia
let paths = [expanduser("~/.guix-profile"), "/run/current-system/profile"]
    ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
ENV["GUIX_ENVIRONMENT"])
    empty!(LOAD_PATH)
    push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
    push!(LOAD_PATH, "@stdlib")
    push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
    nothing
end
#+end_src

With those, I've been able to install the following (with their
dependencies):
- Plots.jl (GR.jl backend)
- HTTP.jl
- Gtk.jl
- Gumbo.jl/Cascadia.jl
- FileIO.jl
- CSVFiles.jl ;; TODO: Fix warnings
- JSON.jl
- JSON2.jl
- MsgPack.jl
- DataFrames.jl
- Query.jl
- SQLite.jl
- Interact.jl

There is a phase called 'precompile' even if I could not get julia actually
use the precompiled packages. This is similar to what emacs does (.el ->
.elc). Even if currently this cache is not used, is useful to have this
phase to verify that package import works.

Now the bad news: this patch is really big (mostly because I wanted to be
sure that in principle installing every package is possible. Before
splitting the second patch into multiple small ones, I wanted to be sure
that what I'm doing is somewhat correct.

Also, even if I was able to install those by using a separate folder (with
guix environment -L .), I'm getting this error now, and I don't know what
is causing it (since I'm not touching those files):

#+begin_example
   626:19  2 (_ #<directory (gnu packages gnuzilla) 805fd20>)
   293:34  1 (_ #(#(#(#(#(#(#(#(#(#(#(#(#<directory (gnu packages gnuzilla)
805fd20> "60.8.0") "60") "8") "0") "60.8.0esr") #<origin "
https://ftp.mozilla.org/pub/firefox/releas?>) #) #) #) #) #) #))
    159:9  0 (_ #(#(#(#(#(#(#(#(#(#(#(#(#<directory (gnu packages gnuzilla)
805fd20> "60.8.0") "60") "8") "0") "60.8.0esr") #<origin "
https://ftp.mozilla.org/pub/firefox/releas?>) #) #) #) #) #) #))

ice-9/eval.scm:159:9: Throw to key `srfi-34' with args `(#<condition
&message [message: "icecat-makeicecat.patch: patch not found"] 8eeae0>)'.
#+end_example

I hope somebody is willed to help getting this in a good state :)
Thanks, Nicolò!
From cd38a16fbc9f78a8eda90c215a6d69a54f9e6c28 Mon Sep 17 00:00:00 2001
From: nixo <[email-masked]>
Date: Mon, 29 Jul 2019 18:45:26 +0200
Subject: [PATCH 1/2] build: Add julia-build-system.

* guix/build/julia-build-system.scm: New file.
* guix/build-system/julia.scm: New file.
* Makefile.am: Added new files.
---
 Makefile.am                       |   2 +
 guix/build-system/julia.scm       | 106 +++++++++++++++++++++
 guix/build/julia-build-system.scm | 147 ++++++++++++++++++++++++++++++
 3 files changed, 255 insertions(+)
 create mode 100644 guix/build-system/julia.scm
 create mode 100644 guix/build/julia-build-system.scm

diff --git a/Makefile.am b/Makefile.am
index 0bd85e8fcf..d14487045a 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -125,6 +125,7 @@ MODULES =					\
   guix/build-system/gnu.scm			\
   guix/build-system/guile.scm			\
   guix/build-system/haskell.scm			\
+  guix/build-system/julia.scm			\
   guix/build-system/linux-module.scm		\
   guix/build-system/node.scm			\
   guix/build-system/perl.scm			\
@@ -183,6 +184,7 @@ MODULES =					\
   guix/build/texlive-build-system.scm		\
   guix/build/waf-build-system.scm		\
   guix/build/haskell-build-system.scm		\
+  guix/build/julia-build-system.scm		\
   guix/build/linux-module-build-system.scm	\
   guix/build/store-copy.scm			\
   guix/build/json.scm				\
diff --git a/guix/build-system/julia.scm b/guix/build-system/julia.scm
new file mode 100644
index 0000000000..a54b0f37f1
--- /dev/null
+++ b/guix/build-system/julia.scm
@@ -0,0 +1,106 @@
+(define-module (guix build-system julia)
+  #:use-module ((guix build julia-build-system))
+  #:use-module (gnu packages julia)
+  #:use-module (guix store)
+  #:use-module (guix utils)
+  #:use-module (guix packages)
+  #:use-module (guix derivations)
+  #:use-module (guix search-paths)
+  #:use-module (guix build-system)
+  #:use-module (guix build-system gnu)
+  #:use-module (ice-9 match)
+  #:use-module (srfi srfi-26)
+  #:export (%julia-build-system-modules
+            julia-build
+            julia-build-system))
+
+(define %julia-build-system-modules
+  ;; Build-side modules imported by default.
+  `((guix build julia-build-system)
+    ,@%gnu-build-system-modules))
+
+(define* (lower name
+                #:key source inputs native-inputs outputs system target
+                (julia julia)
+                #:allow-other-keys
+                #:rest arguments)
+  "Return a bag for NAME."
+  (define private-keywords
+    '(#:target #:julia #:inputs #:native-inputs))
+
+  (and (not target)			;XXX: no cross-compilation
+       (bag
+	(name name)
+	(system system)
+	(host-inputs `(,@(if source
+			     `(("source" ,source))
+			     '())
+		       ,@inputs
+		       ;; Keep the standard inputs of 'gnu-build-system'.
+		       ,@(standard-packages)))
+	(build-inputs `(("julia" ,julia)
+			,@native-inputs))
+	(outputs outputs)
+	(build julia-build)
+	(arguments (strip-keyword-arguments private-keywords arguments)))))
+
+(define* (julia-build store name inputs
+                      #:key source
+                      (tests? #f)
+                      (parallel-tests? #t)
+                      (test-command ''("make" "check"))
+                      (phases '(@ (guix build julia-build-system)
+                                  %standard-phases))
+                      (outputs '("out"))
+                      ;; (include (quote %default-include))
+                      ;; (exclude (quote %default-exclude))
+                      (search-paths '())
+                      (system (%current-system))
+                      (guile #f)
+                      (imported-modules %julia-build-system-modules)
+                      (modules '((guix build julia-build-system)
+                                 (guix build utils))))
+  "Build SOURCE using Julia, and with INPUTS."
+  (define builder
+    `(begin
+       (use-modules ,@modules)
+       (julia-build #:name ,name
+                    #:source ,(match (assoc-ref inputs "source")
+                                (((? derivation? source))
+                                 (derivation->output-path source))
+                                ((source)
+                                 source)
+                                (source
+                                 source))
+                    #:system ,system
+                    #:test-command ,test-command
+                    #:tests? ,tests?
+                    #:phases ,phases
+                    #:outputs %outputs
+                    ;; #:include ,include
+                    ;; #:exclude ,exclude
+                    #:search-paths ',(map search-path-specification->sexp
+                                          search-paths)
+                    #:inputs %build-inputs)))
+
+  (define guile-for-build
+    (match guile
+      ((? package?)
+       (package-derivation store guile system #:graft? #f))
+      (#f                                         ; the default
+       (let* ((distro (resolve-interface '(gnu packages commencement)))
+              (guile  (module-ref distro 'guile-final)))
+         (package-derivation store guile system #:graft? #f)))))
+
+  (build-expression->derivation store name builder
+                                #:inputs inputs
+                                #:system system
+                                #:modules imported-modules
+                                #:outputs outputs
+                                #:guile-for-build guile-for-build))
+
+(define julia-build-system
+  (build-system
+   (name 'julia)
+   (description "The build system for Julia packages")
+   (lower lower)))
diff --git a/guix/build/julia-build-system.scm b/guix/build/julia-build-system.scm
new file mode 100644
index 0000000000..5f222f0850
--- /dev/null
+++ b/guix/build/julia-build-system.scm
@@ -0,0 +1,147 @@
+(define-module (guix build julia-build-system)
+  #:use-module ((guix build gnu-build-system) #:prefix gnu:)
+  #:use-module (guix build utils)
+  ;; #:use-module (srfi srfi-1)
+  ;; #:use-module (srfi srfi-11)
+  ;; #:use-module (srfi srfi-26)
+  ;; #:use-module (ice-9 rdelim)
+  ;; #:use-module (ice-9 regex)
+  #:use-module (ice-9 match)
+  #:export (%standard-phases
+	    julia-create-package-toml
+            julia-build))
+
+;; (define* (set-emacs-load-path #:key source inputs #:allow-other-keys)
+;;   (define (inputs->directories inputs)
+;;     "Extract the directory part from INPUTS."
+;;     (match inputs
+;;       (((names . directories) ...) directories)))
+
+;;   (define (input-directory->el-directory input-directory)
+;;     "Return the correct Emacs Lisp directory in INPUT-DIRECTORY or #f, if there
+;; is no Emacs Lisp directory."
+;;     (let ((legacy-elisp-directory (string-append input-directory %legacy-install-suffix))
+;;           (guix-elisp-directory
+;;            (string-append
+;;             input-directory %install-suffix "/"
+;;             (store-directory->elpa-name-version input-directory))))
+;;       (cond
+;;        ((file-exists? guix-elisp-directory) guix-elisp-directory)
+;;        ((file-exists? legacy-elisp-directory) legacy-elisp-directory)
+;;        (else #f))))
+
+;;   (define (input-directories->el-directories input-directories)
+;;     "Return the list of Emacs Lisp directories in INPUT-DIRECTORIES."
+;;     (filter-map input-directory->el-directory input-directories))
+
+;;   "Set the EMACSLOADPATH environment variable so that dependencies are found."
+;;   (let* ((source-directory (getcwd))
+;;          (input-elisp-directories (input-directories->el-directories
+;;                                    (inputs->directories inputs)))
+;;          (emacs-load-path-value
+;;           (string-join
+;;            (append input-elisp-directories (list source-directory))
+;;            ":" 'suffix)))
+;;     (setenv "EMACSLOADPATH" emacs-load-path-value)
+;;     (format #t "environment variable `EMACSLOADPATH' set to ~a\n"
+;;             emacs-load-path-value)))
+
+
+(define* (install #:key outputs source #:allow-other-keys)
+  (let* ((out (assoc-ref outputs "out"))
+	 (package-dir (string-append out "/share/julia/packages/"
+				     (string-append
+				      (strip-store-file-name source)))))
+    (mkdir-p package-dir)
+    (copy-recursively source package-dir))
+  #t)
+
+;; FIXME: Precompilation is working, but I don't know how to tell
+;; julia to use use it. If setting HOME to
+;; /gnu/store/xib48jxkhiy0gylnm3q430zfwk6am47h-profile/share/julia/compiled/,
+;; julia tries to write files there
+(define* (precompile #:key outputs source inputs #:allow-other-keys)
+  (define (inputs->directories inputs)
+    "Extract the directory part from INPUTS."
+    (match inputs
+      (((names . directories) ...) directories)))
+  (let* ((out (assoc-ref outputs "out"))
+	 (builddir (string-append out "/share/julia/"))
+	 (pacakge (strip-store-file-name source)))
+    (mkdir-p builddir)
+    (setenv "JULIA_DEPOT_PATH" builddir)
+    (setenv "JULIA_LOAD_PATH"
+	    (string-append
+	     "@stdlib:"
+	     (string-append out "/share/julia/packages/:")
+	     (string-join (inputs->directories inputs) "/share/julia/packages/:")))
+    ;; (invoke "julia" "-e" (string-append "println(LOAD_PATH)"))
+    (invoke "julia" "-e" (string-append "using " pacakge))
+    )
+  #t)
+
+;; (define* (check #:key outputs source inputs #:allow-other-keys)
+;;   (define (inputs->directories inputs)
+;;     "Extract the directory part from INPUTS."
+;;     (match inputs
+;;       (((names . directories) ...) directories)))
+;;   (let* ((out (assoc-ref outputs "out"))
+;; 	 (builddir (string-append out "/share/julia/"))
+;; 	 (pacakge (strip-store-file-name source)))
+;;     (mkdir-p builddir)
+;;     (setenv "JULIA_DEPOT_PATH" builddir)
+;;     (setenv "JULIA_LOAD_PATH"
+;;     	    (string-append
+;; 	     "@:@v#.#:@stdlib:"
+;;     	     (string-append out "/share/julia/packages/:")
+;;     	     (string-join (inputs->directories inputs) "/share/julia/packages/:")))
+;;     ;; (invoke "julia" "-e" (string-append "println(LOAD_PATH)"))
+;;     (invoke "julia" "-e" (string-append "using Pkg; Pkg.test(\"" pacakge "\")"))
+;;     )
+;;   #t)
+
+;;* 
+(define (julia-create-package-toml outputs source
+				   name uuid version
+				   deps) 
+  (let ((f (open-file
+	    (string-append
+	     (assoc-ref outputs "out")
+	     "/share/julia/packages/"
+	     (string-append
+	      name "/Project.toml"))
+	    "w")))
+    (display (string-append
+	      "
+name = \"" name "\"
+uuid = \"" uuid "\"
+version = \"" version "\"
+") f)
+    (when (not (null? deps))
+      (display "[deps]\n" f)
+      (for-each (lambda dep
+		  (display (string-append (car (car dep)) " = \"" (cdr (car dep)) "\"\n")
+			   f))
+		deps))
+    (close-port f))
+  #t)
+
+(define %standard-phases
+  (modify-phases gnu:%standard-phases
+    (replace 'install install)
+    (add-after 'install 'precompile precompile)
+    ;; (replace 'check check)
+    ;; (add-after 'unpack 'set-julia-load-path set-julia-load-path)
+    (delete 'configure)
+    (delete 'bootstrap)
+    (delete 'patch-usr-bin-file)
+    (delete 'build)
+    (delete 'reset-gzip-timestamps)
+    (delete 'check)))
+
+(define* (julia-build #:key inputs (phases %standard-phases)
+                      #:allow-other-keys #:rest args)
+  "Build the given Julia package, applying all of PHASES in order."
+  (apply gnu:gnu-build
+         #:inputs inputs #:phases phases
+         args))
-- 
2.22.0

From 5a7a235e2aa81f2b7a65a7101f79f862d1b06e7d Mon Sep 17 00:00:00 2001
From: nixo <[email-masked]>
Date: Tue, 30 Jul 2019 14:33:23 +0200
Subject: [PATCH 2/2] add many julia packages

---
 gnu/local.mk               |    1 +
 gnu/packages/julia-xyz.scm | 3510 ++++++++++++++++++++++++++++++++++++
 2 files changed, 3511 insertions(+)
 create mode 100644 gnu/packages/julia-xyz.scm

diff --git a/gnu/local.mk b/gnu/local.mk
index bd509647dc..8499d5b382 100644
--- a/gnu/local.mk
+++ b/gnu/local.mk
@@ -265,6 +265,7 @@ GNU_SYSTEM_MODULES =				\
   %D%/packages/jrnl.scm				\
   %D%/packages/jose.scm				\
   %D%/packages/julia.scm			\
+  %D%/packages/julia-xyz.scm			\
   %D%/packages/kawa.scm				\
   %D%/packages/kde.scm				\
   %D%/packages/kde-frameworks.scm		\
diff --git a/gnu/packages/julia-xyz.scm b/gnu/packages/julia-xyz.scm
new file mode 100644
index 0000000000..770d2eb6e7
--- /dev/null
+++ b/gnu/packages/julia-xyz.scm
@@ -0,0 +1,3510 @@
+(define-module (gnu packages julia-xyz)
+  #:use-module ((guix licenses) #:prefix license:)
+  #:use-module (guix packages)
+  #:use-module (guix download)
+  #:use-module (guix utils)
+  #:use-module (guix git-download)
+  #:use-module (guix build-system julia)
+  #:use-module (gnu packages)
+  #:use-module (gnu packages julia)
+  #:use-module (gnu packages version-control)
+  #:use-module (ice-9 match)
+  ;; pacakge dependencies
+  #:use-module (gnu packages compression)
+  #:use-module (gnu packages curl)
+  #:use-module (gnu packages glib)
+  #:use-module (gnu packages tls)
+  #:use-module (gnu packages video)
+  #:use-module (gnu packages gtk)
+  #:use-module (gnu packages python-xyz)
+  #:use-module (gnu packages web)
+  #:use-module (gnu packages maths)
+  #:use-module (gnu packages sqlite)
+  )
+
+;; Working top-level packages:
+;; - Plots.jl (GR.jl backend)
+;; - HTTP.jl
+;; - Gtk.jl
+;; - Gumbo.jl/Cascadia.jl
+;; - FileIO.jl
+;; - CSVFiles.jl ;; TODO: Fix warnings
+;; - JSON.jl
+;; - JSON2.jl
+;; - MsgPack.jl
+;; - DataFrames.jl
+;; - Query.jl
+;; - SQLite.jl
+;; - Interact.jl
+;; ;; - WIP GtkReactive.jl
+;; problems:
+;; - Revise.jl: no laoded projects, issues a warning
+;; - IJulia.jl: I'm not myself an Ijulia user, but it would nice to support it.
+;;   however it seems to want to install things to the XDG_DATA_HOME path, JUPYTER_DATA_DIR
+;; Those examples should explain how to add new packages and how to
+;; fix possible problems
+
+;;; TO GET IT WORKING, add this to your ~/.julia/config/startup.jl file
+
+;; let paths = [expanduser("~/.guix-profile"), "/run/current-system/profile"]
+;;     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths, ENV["GUIX_ENVIRONMENT"])
+;;     empty!(LOAD_PATH)
+;;     # f = popfirst!(DEPOT_PATH)
+;;     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
+;;     push!(LOAD_PATH, "@stdlib")
+;;     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
+;;     # push!(DEPOT_PATH, f)
+;;     nothing
+;; end
+
+;;; This is inspired by emacs-xyz and how emacs finds dependencies at
+;;; startup.  It's simplified but seems to do the job, for now.  Also,
+;;; julia will still precompile things to a folder inside $HOME
+;;; ($HOME/.julia/compiled).  Precompilation during install is not
+;;; possible (julia at runtime will still precompile to the home
+;;; directory. Chainging the home directory to the $GUIX_ENVIRONMENT
+;;; path does not work because it's readonly and julia wants to write
+;;; there. So for now, to ensure a clean environment, run julia with
+;;; HOME=$(mktemp -d) julia.
+;;; TODO: Find a better way (e.g., patching julia)
+
+(define-public julia-inifile
+  (package
+    (name "julia-inifile")
+    (version "0.5.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaIO/IniFile.jl.git")
+		    ;; master branch does not have a Project.toml file
+		    (commit "8ba59958495fa276d6489d2c3903e765d75e0bc0")))
+	      (file-name "IniFile")
+	      (sha256
+	       (base32 "11h6f99jpbg729lplw841m68jprka7q3n8yw390bndlmcdsjabpd"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/IniFile.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-compat
+  (package
+    (name "julia-compat")
+    (version "2.1.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaLang/Compat.jl.git")
+		    (commit "a6b2831c438bf9f06f5ddbfdd43c5368a776eab4")))
+	      (file-name "Compat")
+	      (sha256
+	       (base32 "1ynl99w3ylhvzrwx2wbfvmxlz4jx7vwck2nh7j88a0wzsygipmf2"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaLang/Compat.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-binaryprovider
+  ;; In theory we should replace this with a package that errors when used
+  (package
+    (name "julia-binaryprovider")
+    (version "0.5.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPackaging/BinaryProvider.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "BinaryProvider")
+	      (sha256
+	       (base32 "1papsz5ki5iwv1v3ac1ddybjxak93nydh7dqc3231zm0fzd918ys"))))
+    (propagated-inputs `(("julia-sha" ,julia-sha)
+			 ;; ("julia-logging" ,julia-logging)
+			 ))
+    (arguments
+     `(#:phases
+       ;; wants to download things with curl/wget
+       (modify-phases %standard-phases (delete 'precompile))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPackaging/BinaryProvider.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-mbedtls
+  (package
+    (name "julia-mbedtls")
+    (version "0.7.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaWeb/MbedTLS.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "MbedTLS")
+	      (sha256
+	       (base32 "1a8snw9gi21lm6r3kh6ly7ngi99s9k5shqkfiizj3g9li20q23h2"))))
+    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
+			 ("mbedtls-apache" ,mbedtls-apache)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda* (#:key outputs source inputs #:allow-other-keys)
+	     (let ((f (open-file
+		       (string-append
+			(assoc-ref outputs "out")
+			"/share/julia/packages/"
+			(string-append
+			 (strip-store-file-name source) "/deps/deps.jl"))
+		       "w")))
+	       (display (string-append "const libmbedcrypto = \""
+				       (assoc-ref inputs "mbedtls-apache")
+				       "/lib/libmbedcrypto.so\"\n") f)
+	       (display (string-append "const libmbedtls = \""
+				       (assoc-ref inputs "mbedtls-apache")
+				       "/lib/libmbedtls.so\"\n") f)
+	       (display (string-append "const libmbedx509 = \""
+				       (assoc-ref inputs "mbedtls-apache")
+				       "/lib/libmbedx509.so\"\n") f)
+	       (close-port f))
+	     #t)
+	   ))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/MbedTLS.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-bindeps
+  (package
+    (name "julia-bindeps")
+    (version "0.8.10")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPackaging/BinDeps.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "BinDeps")
+	      (sha256
+	       (base32 "1da7z4ii78gaqnjal7c4d1xvicyshiil4ls6xhi9id4q8plmfa2m"))))
+    (propagated-inputs `(("julia-uriparser" ,julia-uriparser)
+			 ("julia-sha" ,julia-sha)
+			 ("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPackaging/BinDeps.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-bufferedstreams
+  (package
+    (name "julia-bufferedstreams")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/BioJulia/BufferedStreams.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "BufferedStreams")
+	      (sha256
+	       (base32 "0sf4sxbq55mg2pwxyxf0c839z1lk0yxg8nmb7617bfbvw31cp88z"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/BioJulia/BufferedStreams.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-libz
+  (package
+    (name "julia-libz")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/BioJulia/Libz.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Libz")
+	      (sha256
+	       (base32 "1434i2hhf8hncnchnrvz1j3gydm83yyglsjggc3i1zzg821pwrbv"))))
+    (propagated-inputs `(("julia-bufferedstreams" ,julia-bufferedstreams)
+			 ("julia-compat" ,julia-compat)
+			 ("zlib" ,zlib)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda*
+	       (#:key outputs source inputs #:allow-other-keys)
+	     (substitute* (string-append (assoc-ref outputs "out") "/share/julia/packages/"
+					 (string-append (strip-store-file-name source) "/src/lowlevel.jl"))
+	       (("const zlib = \"libz\"")
+		(string-append "const zlib = \""
+			       (assoc-ref inputs "zlib")
+			       "/lib/libz.so\"\n")))
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/BioJulia/Libz.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-libepat
+  (package
+    (name "julia-libexpat")
+    (version "0.5.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaIO/LibExpat.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "LibExpat")
+	      (sha256
+	       (base32 "1iny18z76bkf3yi6cvpfia7z1j7kn789iy0nwigsj2sb9mfi5x8b"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/LibExpat.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-libcurl
+  (package
+    (name "julia-libcurl")
+    (version "0.5.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaWeb/LibCURL.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "LibCURL")
+	      (sha256
+	       (base32 "1kwpk19338wvnq67nimdzp815hzhvbpk77qp2r851f7szqjbd1qc"))))
+    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
+			 ("curl" ,curl)
+			 ("zlib" ,zlib)
+			 ("mbedtls-apache" ,mbedtls-apache)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda* (#:key outputs source inputs #:allow-other-keys)
+	     (let ((f (open-file
+		       (string-append
+			(assoc-ref outputs "out")
+			"/share/julia/packages/"
+			(string-append
+			 (strip-store-file-name source) "/deps/deps.jl"))
+		       "w")))
+	       
+	       (display (string-append "const libcurl = \""
+				       (assoc-ref inputs "curl")
+				       "/lib/libcurl.so\"\n") f)
+	       (display (string-append "const libz = \""
+				       (assoc-ref inputs "zlib")
+				       "/lib/libz.so\"\n") f)
+	       (display (string-append "const libmbedcrypto = \""
+				       (assoc-ref inputs "mbedtls-apache")
+				       "/lib/libmbedcrypto.so\"\n") f)
+	       (display (string-append "const libmbedcrypto = \""
+				       (assoc-ref inputs "mbedtls-apache")
+				       "/lib/libmbedcrypto.so\"\n") f)
+	       (display (string-append "const libmbedtls = \""
+				       (assoc-ref inputs "mbedtls-apache")
+				       "/lib/libmbedtls.so\"\n") f)
+	       (display (string-append "const libmbedx509 = \""
+				       (assoc-ref inputs "mbedtls-apache")
+				       "/lib/libmbedx509.so\"\n") f) 
+	       (display (string-append "check_deps() = nothing\n") f)
+	       (close-port f))
+	     #t)
+	   ))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/LibCURL.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-http
+  (package
+    (name "julia-http")
+    (version "0.8.4")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaWeb/HTTP.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "HTTP")
+	      (sha256
+	       (base32 "1h2cgjijlmciljdfz4lqigq8lhrvdax5k5ffflvpv2anniywmsx0"))))
+    (propagated-inputs `(("julia-inifile" ,julia-inifile)
+			 ("julia-mbedtls" ,julia-mbedtls)
+			 ("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/HTTP.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-iteratorinterfaceextensions
+  (package
+    (name "julia-iteratorinterfaceextensions")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/IteratorInterfaceExtensions.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "IteratorInterfaceExtensions")
+	      (sha256
+	       (base32 "1slpay1dhja8f9gy6z7b3psgvgcknn963dvfqqakvg1grk9ppa09"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/IteratorInterfaceExtensions.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-tabletraits
+  (package
+    (name "julia-tabletraits")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/TableTraits.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "TableTraits")
+	      (sha256
+	       (base32 "0lzb9xqnhgjbvkscc4p9vw3pzajm3a5a6ayv6byqc53ws8fxqk2v"))))
+    (propagated-inputs `(("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/TableTraits.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-dataapi
+  (package
+    (name "julia-dataapi")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/DataAPI.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataAPI")
+	      (sha256
+	       (base32 "19zr2y10bdp5harrjsjgx4b5xr7hvhay0my584vxfj1m7rksz3sn"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/DataAPI.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-datavalues
+  (package
+    (name "julia-datavalues")
+    (version "0.4.12")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/DataValues.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataValues")
+	      (sha256
+	       (base32 "1x0si392psc6drc1x9vnzln4ai4y483n639yd7wqkn5h1nsxaa1c"))))
+    (propagated-inputs `(("julia-datavalueinterfaces" ,julia-datavalueinterfaces)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/DataValues.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-datavalueinterfaces
+  (package
+    (name "julia-datavalueinterfaces")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/DataValueInterfaces.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataValueInterfaces")
+	      (sha256
+	       (base32 "0g2wj6q7jj956nx6g7dk8x7w1c4l2xcmnr1kq5x8s8fild9kslg8"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/DataValueInterfaces.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-tables
+  (package
+    (name "julia-tables")
+    (version "0.2.10")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/Tables.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Tables")
+	      (sha256
+	       (base32 "1x04cdfxqmf4n4a9xyg5md4j2h1izzypjyd3plp7gzk2bvip53jv"))))
+    (propagated-inputs `(("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
+			 ("julia-tabletraits" ,julia-tabletraits)
+			 ("julia-dataapi" ,julia-dataapi)
+			 ("julia-datavalueinterfaces" ,julia-datavalueinterfaces)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/Tables.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-missings
+  (package
+    (name "julia-missings")
+    (version "0.4.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/Missings.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Missings")
+	      (sha256
+	       (base32 "07zlhyh6j2j1gs7fp166bj6zqdgasd0d1scpbcymwpzgq9anp8v0"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/Missings.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-orderedcollections
+  (package
+    (name "julia-orderedcollections")
+    (version "1.1.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaCollections/OrderedCollections.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "OrderedCollections")
+	      (sha256
+	       (base32 "0rh1w8sb69b8670xqd3j0xh7pfsl89jhq66xdrdp0060lif5i5li"))))
+    (propagated-inputs `())
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "OrderedCollections"
+	      "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
+	      "1.1.0"
+	      '())
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaCollections/OrderedCollections.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-datastructures
+  (package
+    (name "julia-datastructures")
+    (version "0.17.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaCollections/DataStructures.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataStructures")
+	      (sha256
+	       (base32 "19d1k021ipy1wr0w0l7m2jnspwzp2rvl2yhcsal9kzfl2wl0a7r8"))))
+    (propagated-inputs `(("julia-orderedcollections" ,julia-orderedcollections)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaCollections/DataStructures.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-arrayviews
+;;   (package
+;;     (name "julia-arrayviews")
+;;     (version "0.7.0")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaArrays/ArrayViews.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "ArrayViews")
+;; 	      (sha256
+;; 	       (base32 "0xs1if4dhy2m604r1ivzvyki6jap7xl8hkiinhi34qplflnr56f1"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaArrays/ArrayViews.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-numericfuns
+;;   (package
+;;     (name "julia-numericfuns")
+;;     (version "0.2.4")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/lindahua/NumericFuns.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "NumericFuns")
+;; 	      (sha256
+;; 	       (base32 "1viv2bl4fbxwny52d4alpsgas8qs1i0yw0ld19nzgv44ivpd4mgj"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/lindahua/NumericFuns.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-numericextensions
+;;   (package
+;;     (name "julia-numericextensions")
+;;     (version "0.6.2")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/lindahua/NumericExtensions.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "NumericExtensions")
+;; 	      (sha256
+;; 	       (base32 "0qr7k45jp3zcrq9jgl61k5hvkxs0h1z90wl6ksfaz8gb848v7s0w"))))
+;;     (propagated-inputs `(;; ("julia-arrayviews" ,julia-arrayviews)
+;; 			 ;; ("julia-numericfuns" ,julia-numericfuns)
+;; 			 ))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/lindahua/NumericExtensions.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; NO Project.toml, julia fails to import DataFrames .-.
+(define-public julia-sortingalgorithms
+  (package
+    (name "julia-sortingalgorithms")
+    (version "0.3.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaCollections/SortingAlgorithms.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "SortingAlgorithms")
+	      (sha256
+	       (base32 "1nz96sccgl6h6aknck59gmy1yrzx356kk9z68svj2g6yialprv1j"))))
+    (propagated-inputs `(("julia-datastructures" ,julia-datastructures)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "SortingAlgorithms"
+	      "a2af1166-a08f-5f64-846c-94a0d3cef48c"
+	      "0.3.1"
+	      '(("DataStructures" . "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8")))
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaCollections/SortingAlgorithms.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-statsbase
+  (package
+    (name "julia-statsbase")
+    (version "0.31.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaStats/StatsBase.jl.git")
+		    (commit "b9454f979ff8bdbc3ecffe2490cc1331a824e798")))
+	      (file-name "StatsBase")
+	      (sha256
+	       (base32 "1k6zcblpdrdq568lsgna83ld2kj47h2cxn5idp8g41fdm9scph5b"))))
+    (propagated-inputs `(("julia-datastructures" ,julia-datastructures)
+			 ;; ("julia-numericextensions" ,julia-numericextensions)
+			 ("julia-sortingalgorithms" ,julia-sortingalgorithms)
+			 ("julia-missings" ,julia-missings)
+			 ("julia-dataapi" ,julia-dataapi)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaStats/StatsBase.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-reexport
+  (package
+    (name "julia-reexport")
+    (version "0.2.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/simonster/Reexport.jl.git")
+		    (commit "258a4088bb77ee4821bf2da1c73fd6e4897fd43c")))
+	      (file-name "Reexport")
+	      (sha256
+	       (base32 "0h8pfqwz0g0gywcsr5f7s3z6g7q0mmlb2ynki2nn16r8x4i074nx"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/simonster/Reexport.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-nullablearrays
+;;   (package
+;;     (name "julia-nullablearrays")
+;;     (version "0.1.2")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaStats/NullableArrays.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "NullableArrays")
+;; 	      (sha256
+;; 	       (base32 "18sl4ck311wjdnv7hw6jg8yd0n8njzcfq9psz7khhr53j9c6r4ab"))))
+;;     (propagated-inputs `(;; ("julia-statsbase" ,julia-statsbase)
+;; 			 ("julia-reexport" ,julia-reexport)
+;; 			 ("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaStats/NullableArrays.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-parsers
+  (package
+    (name "julia-parsers")
+    (version "0.3.6")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/Parsers.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Parsers")
+	      (sha256
+	       (base32 "1xjfg72ip7i5xci6nfc88swyny4dsarxqavfcfa2snjir1jws1zk"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/Parsers.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-json
+  (package
+    (name "julia-json")
+    (version "0.21.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaIO/JSON.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "JSON")
+	      (sha256
+	       (base32 "0knmfjhchd3ggy86dsfyb7l4v3fv5dcr207cgp54mj7rj96caqsm"))))
+    (propagated-inputs `(("julia-parsers" ,julia-parsers)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/JSON.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-categoricalarrays
+  (package
+    (name "julia-categoricalarrays")
+    (version "0.5.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/CategoricalArrays.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CategoricalArrays")
+	      (sha256
+	       (base32 "0bqq20w64pjvd2mfvisqx1z7dn344ady6942jq80xr0jbc4rjdxh"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)
+			 ;; ("julia-nullablearrays" ,julia-nullablearrays)
+			 ("julia-missings" ,julia-missings)
+			 ("julia-dataapi" ,julia-dataapi)
+			 ("julia-reexport" ,julia-reexport)
+			 ("julia-json" ,julia-json)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/CategoricalArrays.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-invertedindices
+  (package
+    (name "julia-invertedindices")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/mbauman/InvertedIndices.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "InvertedIndices")
+	      (sha256
+	       (base32 "1179z20yxnkyziip7gn26wr1g3k3ssl1ci7pig3khc900f62di46"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/mbauman/InvertedIndices.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-stats
+  (package
+    (name "julia-stats")
+    (version "0.1.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaStats/StatsKit.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Stats")
+	      (sha256
+	       (base32 "0vz6183rj9122d53i35x86fzir6cq2sjhqmacb1id140d2ab80zl"))))
+    (propagated-inputs `(("julia-statsbase" ,julia-statsbase)
+			 ("julia-orderedcollections" ,julia-orderedcollections)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaStats/StatsKit.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-fixedpointnumbers
+  (package
+    (name "julia-fixedpointnumbers")
+    (version "0.6.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaMath/FixedPointNumbers.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "FixedPointNumbers")
+	      (sha256
+	       (base32 "033s9gi94xs97kshy2mcx5mvdkigdf4aqgaa6qgq6kz4s6gbpa9r"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaMath/FixedPointNumbers.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-tokenize
+  (package
+    (name "julia-tokenize")
+    (version "0.5.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaLang/Tokenize.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Tokenize")
+	      (sha256
+	       (base32 "072j40xb3v8zcn3zjzv60iznanplvm4bn0lnz9xhri1sx2y2l5g0"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaLang/Tokenize.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-uriparser
+  (package
+    (name "julia-uriparser")
+    (version "0.4.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaWeb/URIParser.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "URIParser")
+	      (sha256
+	       (base32 "1i45wza6jh9k7x8jrqiil6k2yb81hdzm3s0zqhzy3y2sby66p44p"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/URIParser.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-sha
+  (package
+    (name "julia-sha")
+    (version "0.5.7")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/staticfloat/SHA.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "SHA")
+	      (sha256
+	       (base32 "10a09kg9z0m8rvwmlgsna6p342kyvizx2axdqc6pzyhraddr8jrp"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/staticfloat/SHA.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-bindeps
+  (package
+    (name "julia-bindeps")
+    (version "0.8.10")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPackaging/BinDeps.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "BinDeps")
+	      (sha256
+	       (base32 "1da7z4ii78gaqnjal7c4d1xvicyshiil4ls6xhi9id4q8plmfa2m"))))
+    (propagated-inputs `(("julia-uriparser" ,julia-uriparser)
+			 ("julia-sha" ,julia-sha)
+			 ("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPackaging/BinDeps.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-cstparser
+  (package
+    (name "julia-cstparser")
+    (version "0.6.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/julia-vscode/CSTParser.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CSTParser")
+	      (sha256
+	       (base32 "1m6y6jd703d9xyhhm00d5whbirsyy99wjcqmdvwxkjf9nm77ifzv"))))
+    (propagated-inputs `(("julia-tokenize" ,julia-tokenize)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/julia-vscode/CSTParser.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-macrotools
+  (package
+    (name "julia-macrotools")
+    (version "0.5.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/MikeInnes/MacroTools.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "MacroTools")
+	      (sha256
+	       (base32 "0sspp8na3cj7pni1b3dqzzpv2mkzln4f5w0n0wrh2jvn8rz1fjjx"))))
+    ;; CANT FIND COMPAT!
+    (propagated-inputs `(("julia-compat" ,julia-compat)
+			 ("julia-tokenize" ,julia-tokenize)
+			 ("julia-datastructures" ,julia-datastructures)
+			 ("julia-cstparser" ,julia-cstparser)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/MikeInnes/MacroTools.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-lazy
+  (package
+    (name "julia-lazy")
+    (version "0.13.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/MikeInnes/Lazy.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Lazy")
+	      (sha256
+	       (base32 "06ffflpjqv27wgali44lj68dplfmjind421jjrvgja5p2lyh2krg"))))
+    (propagated-inputs `(("julia-macrotools" ,julia-macrotools)
+			 ("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       ;; macrotools can't find compat
+       (modify-phases %standard-phases (delete 'precompile))))
+    (home-page "https://github.com/MikeInnes/Lazy.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-markdown
+  (package
+    (name "julia-markdown")
+    (version "0.3.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaAttic/Markdown.jl.git")
+		    (commit "d17f3b19282e719a33b169ea46d660d51bbf5a9d")))
+	      (file-name "Markdown")
+	      (sha256
+	       (base32 "02hfx3x86w4cf4xq0nihs8h4qvqrybfrpsl9h8bsh4b077dwzi1s"))))
+    (propagated-inputs `(("julia-lazy" ,julia-lazy)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaAttic/Markdown.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-docile
+;;   (package
+;;     (name "julia-docile")
+;;     (version "0.5.23")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/MichaelHatherly/Docile.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "Docile")
+;; 	      (sha256
+;; 	       (base32 "1r35wdkp6zxf4b66n7fqsw56y0gr04hn4rrzcmsba346lb39r8b8"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)
+;; 			 ("julia-markdown" ,julia-markdown)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/MichaelHatherly/Docile.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-fixedsizearrays
+;;   (package
+;;     (name "julia-fixedsizearrays")
+;;     (version "0.2.5")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/SimonDanisch/FixedSizeArrays.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "FixedSizeArrays")
+;; 	      (sha256
+;; 	       (base32 "0hi9qv0b9p951ciss51gdsprvdr5iqk6ga5vm6is830bwbvvn73k"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/SimonDanisch/FixedSizeArrays.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-colortypes
+  (package
+    (name "julia-colortypes")
+    (version "0.8.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGraphics/ColorTypes.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "ColorTypes")
+	      (sha256
+	       (base32 "0yskbz6598aaa36502jzq59aqqy0daxcrcxcmhk6jnbb5a1psr95"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)
+			 ;; ("julia-docile" ,julia-docile)
+			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
+			 ;; ("julia-fixedsizearrays" ,julia-fixedsizearrays)
+			 ))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/ColorTypes.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-colors
+  (package
+    (name "julia-colors")
+    (version "0.9.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGraphics/Colors.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Colors")
+	      (sha256
+	       (base32 "1a6qvhim024i524g6xjz7q8fjkgm9mbdhrqi18rrxrjmby0cr92a"))))
+    (propagated-inputs `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
+			 ("julia-colortypes" ,julia-colortypes)
+			 ("julia-reexport" ,julia-reexport)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/Colors.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-nanmath
+  (package
+    (name "julia-nanmath")
+    (version "0.3.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/mlubin/NaNMath.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "NaNMath")
+	      (sha256
+	       (base32 "17cp9fnz8ydl684dkkqbsgi4c6xkd9skwrjyscawns9c1fhnzl2l"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "NaNMath"
+	      "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
+	      "0.3.2"
+	      '(("Compat" . "34da2185-b29b-5c13-b0c7-acf172513d20")))
+	     #t)))))
+    (home-page "https://github.com/mlubin/NaNMath.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-graphics
+  (package
+    (name "julia-graphics")
+    (version "0.4.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGraphics/Graphics.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Graphics")
+	      (sha256
+	       (base32 "03d98j49fn7zkhxki5n1b1br9p9hs380dpdp0a480m7yh1c45091"))))
+    (propagated-inputs `(("julia-colors" ,julia-colors)
+			 ("julia-nanmath" ,julia-nanmath)
+			 ("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "Graphics"
+	      "a2bd30eb-e257-5431-a919-1863eab51364"
+	      "0.4.0"
+	      '())
+	     #t)))))
+    (home-page "https://github.com/JuliaGraphics/Graphics.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-color
+;;   (package
+;;     (name "julia-color")
+;;     (version "0.4.8")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaAttic/Color.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "Color")
+;; 	      (sha256
+;; 	       (base32 "011nhc7hd9yvn59aq58dvd84hsxd2z7x2949bi69w095vz8iciky"))))
+;;     (propagated-inputs `(("julia-graphics" ,julia-graphics)
+;; 			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
+;; 			 ("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaAttic/Color.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-terminals
+;;   (package
+;;     (name "julia-terminals")
+;;     (version "0.0.1")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/Keno/Terminals.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "Terminals")
+;; 	      (sha256
+;; 	       (base32 "1xc5w82c19b17ydglpr03mnzr07mpc59jzf5b5wca6qrilqdx8qb"))))
+;;     (propagated-inputs `(;; ("julia-color" ,julia-color)
+;; 			 ))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/Keno/Terminals.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-lineedit
+;;   (package
+;;     (name "julia-lineedit")
+;;     (version "0.0.1")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/Keno/LineEdit.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "LineEdit")
+;; 	      (sha256
+;; 	       (base32 "05ily5jmznyzb00c0pwlgwplvmkyvcalcia3k438p3agnqpqkrnh"))))
+;;     (propagated-inputs `(;; ("julia-terminals" ,julia-terminals)
+;; 			 ))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/Keno/LineEdit.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-repl
+;;   (package
+;;     (name "julia-repl")
+;;     (version "0.0.2")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/Keno/REPL.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "REPL")
+;; 	      (sha256
+;; 	       (base32 "1zf0x5rkj0i31z4idws0pwsdpv3yv5m0amjzgfyla7dsv7mv0d7i"))))
+;;     (propagated-inputs `(;; ("julia-lineedit" ,julia-lineedit)
+;; 			 ))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/Keno/REPL.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-pooledarrays
+  (package
+    (name "julia-pooledarrays")
+    (version "0.5.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/PooledArrays.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "PooledArrays")
+	      (sha256
+	       (base32 "0sdn965bb93api43dj8dsd32lp3yyh53mp22xr0vfj115x3ym2wj"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/PooledArrays.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-dataframes
+  (package
+    (name "julia-dataframes")
+    (version "0.19.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/DataFrames.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataFrames")
+	      (sha256
+	       (base32 "0i58khcg486k7affkkj43b23zrg4flmy85s9rkwp021gnal80p6b"))))
+    (propagated-inputs `(("julia-tables" ,julia-tables)
+			 ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
+			 ("julia-tabletraits" ,julia-tabletraits)
+			 ("julia-missings" ,julia-missings)
+			 ("julia-categoricalarrays" ,julia-categoricalarrays)
+			 ("julia-invertedindices" ,julia-invertedindices)
+			 ("julia-stats" ,julia-stats)
+			 ("julia-compat" ,julia-compat)
+			 ;; ("julia-repl" ,julia-repl)
+			 ("julia-pooledarrays" ,julia-pooledarrays)
+			 ("julia-sortingalgorithms" ,julia-sortingalgorithms)
+			 ("julia-reexport" ,julia-reexport)
+			 ("julia-dataapi" ,julia-dataapi)
+			 ("julia-parsers" ,julia-parsers)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/DataFrames.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-measures
+  (package
+    (name "julia-measures")
+    (version "0.3.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGraphics/Measures.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Measures")
+	      (sha256
+	       (base32 "020yf4a7wmm0jhkpzxgz4bif2l4l0zmrzagz0gc2hrvnz0kp9m3b"))))
+    (propagated-inputs `())
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "Measures"
+	      "442fdcdd-2543-5da2-b0f3-8c86c306513e"
+	      "0.3.0"
+	      '())
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/Measures.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-plotutils
+  (package
+    (name "julia-plotutils")
+    (version "0.5.8")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPlots/PlotUtils.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "PlotUtils")
+	      (sha256
+	       (base32 "0406jq64fyramfjqzfw4p0lsgs9p2sindxximzmcsav8ha7r0vwy"))))
+    (propagated-inputs `(("julia-colors" ,julia-colors)
+			 ("julia-reexport" ,julia-reexport)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "PlotUtils"
+	      "995b91a9-d308-5afd-9ec6-746e21dbc043"
+	      "0.5.8"
+	      '(("Dates" . "ade2ca70-3891-5945-98fb-dc099432e06a")
+		("Reexport" . "189a3867-3050-52da-a836-e630ba90ab69")
+		("Printf" . "de0858da-6303-5e67-8744-51eddeeeb8d7")
+		("Colors" . "5ae59095-9a9b-59fe-a467-6f913c188581")
+		("Random" . "9a3f8284-a2c9-5f02-9a11-845980a1fd5c")))
+	     #t)))))
+    (home-page "https://github.com/JuliaPlots/PlotUtils.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-immutablearrays
+;;   (package
+;;     (name "julia-immutablearrays")
+;;     (version "0.0.12")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaGeometry/ImmutableArrays.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "ImmutableArrays")
+;; 	      (sha256
+;; 	       (base32 "0yvj494crpkvk8h38iqz6kcr66bhl394pgy2jg2w960dw3bp4y21"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaGeometry/ImmutableArrays.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-staticarrays
+  (package
+    (name "julia-staticarrays")
+    (version "0.11.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaArrays/StaticArrays.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "StaticArrays")
+	      (sha256
+	       (base32 "0ni4rdq8qq4c7m49my885ispilqvhbza0id92j16rqzhdff8bghg"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaArrays/StaticArrays.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-contour
+  (package
+    (name "julia-contour")
+    (version "0.5.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGeometry/Contour.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Contour")
+	      (sha256
+	       (base32 "0l7zi2xshyv81xlp1szm47f6200lnhfylfdrsk7g0xiajr81acpd"))))
+    (propagated-inputs `(;; ("julia-immutablearrays" ,julia-immutablearrays)
+			 ("julia-staticarrays" ,julia-staticarrays)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGeometry/Contour.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-requires
+  (package
+    (name "julia-requires")
+    (version "0.5.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/MikeInnes/Requires.jl.git")
+		    (commit "b2319cd875118c8da8ca099bcd733246ede13628")))
+	      (file-name "Requires")
+	      (sha256
+	       (base32 "00ksdsdgn8pdr9v7263pdmnqmp14pmn6qpf0bvi8n0g59f2nibi9"))))
+    (propagated-inputs `(("julia-macrotools" ,julia-macrotools)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/MikeInnes/Requires.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-itertools
+  (package
+    (name "julia-itertools")
+    (version "1.2.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaCollections/IterTools.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "IterTools")
+	      (sha256
+	       (base32 "1iq08xpj1gb2wz2hx7g177clxnxcwlma12dj240xnk7q0g623hbv"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaCollections/IterTools.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-geometrytypes
+  (package
+    (name "julia-geometrytypes")
+    (version "0.7.3")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGeometry/GeometryTypes.jl.git")
+		    (commit "9294dcba10e7fbb4b6f504b6c56d3fcbc3bc5ca7")))
+	      (file-name "GeometryTypes")
+	      (sha256
+	       (base32 "1skg4rx0a0ripm68ahj926xsqyd7zqkqlqij02l16n0x1k1cvbj4"))))
+    (propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)
+			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
+			 ("julia-itertools" ,julia-itertools)
+			 ("julia-colortypes" ,julia-colortypes)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGeometry/GeometryTypes.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-plotthemes
+  (package
+    (name "julia-plotthemes")
+    (version "0.3.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPlots/PlotThemes.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "PlotThemes")
+	      (sha256
+	       (base32 "1hyrhfn3rhiw96743zlqzr5z67vgyrfpqqy23yww7zh0x3qzm5m0"))))
+    (propagated-inputs `(("julia-plotutils" ,julia-plotutils)
+			 ("julia-requires" ,julia-requires)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "PlotThemes"
+	      "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
+	      "0.3.0"
+	      '(("PlotUtils" . "995b91a9-d308-5afd-9ec6-746e21dbc043")
+		("Requires" . "ae029012-a4dd-5104-9daa-d747884805df")
+		("Statistics" . "10745b16-79ce-11e8-11f9-7d13ad32a3b2")))
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPlots/PlotThemes.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; -- THIS SHOULD BE MOVED SOMEWHERE ELSE!
+(use-modules ((guix licenses) #:prefix license:))
+(use-modules (guix packages))
+(use-modules (guix build-system gnu))
+(use-modules (guix git-download))
+(use-modules (guix download))
+
+(use-modules (gnu packages gcc))
+(use-modules (gnu packages qt))
+(use-modules (gnu packages networking))
+(use-modules (gnu packages gtk))
+(use-modules (gnu packages gl))
+(use-modules (gnu packages image))
+(use-modules (gnu packages xorg))
+
+(define-public gr
+  (package
+    (name "gr")
+    (version "0.40.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url (string-append
+			  "https://github.com/jheinen/" name))
+		    (commit (string-append "v" version))))
+	      (file-name (git-file-name name version))
+	      (sha256
+	       (base32
+		"1fx11ha2lprx9y9h9l5lcsrdgp0kxxznf4qa8ci3n1lds89cpyp4"))
+	      (modules '((guix build utils)))))
+    (build-system gnu-build-system)
+    (arguments
+     '(#:parallel-build? #f 		; fails when parallel
+       #:phases
+       (modify-phases %standard-phases
+	 (delete 'configure)
+	 (delete 'check)
+	 (delete 'validate-runpath)
+	 (add-before 'build 'fix-zeromq
+	   (lambda _
+	     ;; remove prerequisites from targets (we already have zmq)
+	     (substitute* "lib/gks/Makefile"
+	       (("targets: prerequisites libGKS.a") "targets: libGKS.a"))
+	     #t))
+	 (add-before 'build 'fix-gks-install
+	   (lambda _
+	     ;; fonts and header has already been copied, override is needed
+	     (substitute* "lib/gks/Makefile"
+	       (("cp -a fonts") "cp -af fonts"))
+	     (substitute* "lib/gks/Makefile"
+	       (("cp -p gks.h") "cp -pf gks.h"))
+	     #t)))
+       #:make-flags
+       (list "CC=gcc"
+	     (string-append "GRDIR=" (assoc-ref %outputs "out")))))
+    (inputs
+     `(("gcc" ,gcc-8)
+       ("qt" ,qtbase)
+       ("zmq" ,zeromq)
+       ("czmq" ,czmq)
+       ("cairo" ,cairo)
+       ("glfw" ,glfw)
+       ("libtiff" ,libtiff)
+       ("x11" ,libx11)
+       ("xt" ,libxt)))
+    (home-page "http://gr-framework.org")
+    (synopsis "Universal framework for cross-platform visualization applications.")
+    (description "Offers developers a compact, portable and consistent graphics library for their programs.
+Applications range from publication quality 2D graphs to the representation of complex 3D scenes.")
+    (license license:expat)))
+;; --- until here
+
+
+(define-public julia-gr
+  (package
+    (name "julia-gr")
+    (version "0.40.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/jheinen/GR.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "GR")
+	      (sha256
+	       (base32 "0nmrc6xj4n55gv47d4ca9lhz053b26i1jq0nsis09w5mgz3y6nkl"))))
+    (propagated-inputs `(("gr" ,gr)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda*
+	       (#:key outputs source inputs #:allow-other-keys)
+	     (substitute* (string-append (assoc-ref outputs "out") "/share/julia/packages/"
+					 (string-append (strip-store-file-name source) "/src/GR.jl"))
+	       (("const libGR = \"libGR.so\"")
+		(string-append "const libGR = \""
+			       (assoc-ref inputs "gr")
+			       "/lib/libGR.so\""))
+	       (("const libGR3 = \"libGR3.so\"")
+		(string-append "const libGR3 = \""
+			       (assoc-ref inputs "gr")
+			       "/lib/libGR3.so\""))
+	       ((" = grdir")
+		(string-append " = \""
+			       (assoc-ref inputs "gr")
+			       "\"")))
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/jheinen/GR.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+
+(define-public julia-ffmpeg
+  (package
+    (name "julia-ffmpeg")
+    (version "0.2.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaIO/FFMPEG.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "FFMPEG")
+	      (sha256
+	       (base32 "0nbdm8ljizcgjmcaa12j3cv84yhcvnlna9g1l86m8gf8nhackwa5"))))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda* (#:key outputs source inputs #:allow-other-keys)
+	     (let ((f (open-file
+		       (string-append
+			(assoc-ref outputs "out")
+			"/share/julia/packages/"
+			(string-append
+			 (strip-store-file-name source) "/deps/deps.jl"))
+		       "w")))
+	       (display (string-append "const libavcodec = \""
+				       (assoc-ref inputs "ffmpeg")
+				       "/lib/libavcodec.so\"\n") f)
+	       (display (string-append "const libavformat = \""
+				       (assoc-ref inputs "ffmpeg")
+				       "/lib/libavformat.so\"\n") f)
+	       (display (string-append "const libavcodec = \""
+				       (assoc-ref inputs "ffmpeg")
+				       "/lib/libavcodec.so\"\n") f)
+	       (display (string-append "const libavutil = \""
+				       (assoc-ref inputs "ffmpeg")
+				       "/lib/libavutil.so\"\n") f)
+	       (display (string-append "const libswscale = \""
+				       (assoc-ref inputs "ffmpeg")
+				       "/lib/libswscale.so\"\n") f)
+	       (display (string-append "const libavdevice = \""
+				       (assoc-ref inputs "ffmpeg")
+				       "/lib/libavdevice.so\"\n") f)
+	       (display (string-append "const libavfilter = \""
+				       (assoc-ref inputs "ffmpeg")
+				       "/lib/libavfilter.so\"\n") f)
+	       (display (string-append "const ffmpeg = \""
+				       (assoc-ref inputs "ffmpeg")
+				       "/bin/ffmpeg\"\n") f)
+	       (close-port f))
+	     (substitute*
+		 (string-append (assoc-ref outputs "out") "/share/julia/packages/"
+				(string-append (strip-store-file-name source) "/src/FFMPEG.jl"))
+	       (("const libpath = joinpath(@__DIR__, \"..\", \"deps\", \"usr\", \"lib\")")
+		(string-append "const libpath = \""
+			       (assoc-ref inputs "ffmpeg")
+			       "/lib")))
+	     
+	     #t)
+	   ))))
+    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
+			 ("ffmpeg" ,ffmpeg)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/FFMPEG.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-recipesbase
+  (package
+    (name "julia-recipesbase")
+    (version "0.7.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPlots/RecipesBase.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "RecipesBase")
+	      (sha256
+	       (base32 "18dkzvnx6jcqvjaqx592bbxv5wgsl75japq56ij2s8p6gc868lvs"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPlots/RecipesBase.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+
+;; (define-public julia-iterators
+;;   (package
+;;     (name "julia-iterators")
+;;     (version "0.3.1")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaCollections/Iterators.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "Iterators")
+;; 	      (sha256
+;; 	       (base32 "1iixfcc4mq928a0jjrd4nvl58dawxxwv7935wk3m7fh7gb6r68yk"))))
+;;     (propagated-inputs `())
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaCollections/Iterators.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-showoff
+  (package
+    (name "julia-showoff")
+    (version "0.2.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGraphics/Showoff.jl.git")
+		    (commit "8502c2ec11f93c4f50c609ff4168aab31154b39d")))
+	      (file-name "Showoff")
+	      (sha256
+	       (base32 "10iydva8vqlfv4i5jw31q9pc7877syd0bfz2djg93xdy90l4c617"))))
+    (propagated-inputs `( ;; ("julia-iterators" ,julia-iterators)
+			 ("julia-compat" ,julia-compat)
+			 ))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/Showoff.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-plots
+  (package
+    (name "julia-plots")
+    (version "0.26.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPlots/Plots.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Plots")
+	      (sha256
+	       (base32 "1n3az78fzj5h2g3xh0aar2rq5qfnwfidk0szn4c8v7m2sn69yi15"))))
+    (propagated-inputs `(("julia-reexport" ,julia-reexport)
+			 ("julia-json" ,julia-json)
+			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
+			 ("julia-nanmath" ,julia-nanmath)
+			 ("julia-statsbase" ,julia-statsbase)
+			 ("julia-measures" ,julia-measures)
+			 ("julia-plotutils" ,julia-plotutils)
+			 ("julia-contour" ,julia-contour)
+			 ("julia-requires" ,julia-requires)
+			 ("julia-geometrytypes" ,julia-geometrytypes)
+			 ("julia-plotthemes" ,julia-plotthemes)
+			 ;; ("julia-repl" ,julia-repl)
+			 ("julia-gr" ,julia-gr)
+			 ("julia-ffmpeg" ,julia-ffmpeg)
+			 ("julia-recipesbase" ,julia-recipesbase)
+			 ("julia-showoff" ,julia-showoff)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPlots/Plots.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-codetracking
+  (package
+    (name "julia-codetracking")
+    (version "0.5.7")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/timholy/CodeTracking.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CodeTracking")
+	      (sha256
+	       (base32 "0ycwhxfj9y618wixffxqfmr7vyx6ww3fax7c1n1i1hizsgsgfjwl"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/timholy/CodeTracking.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-juliainterpreter
+  (package
+    (name "julia-juliainterpreter")
+    (version "0.6.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaDebug/JuliaInterpreter.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "JuliaInterpreter")
+	      (sha256
+	       (base32 "0mgr7fghc33gb9pmjqp7yrqrw79d0inj4vn384fmgl2yr1q4k86p"))))
+    (propagated-inputs `(("julia-codetracking" ,julia-codetracking)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaDebug/JuliaInterpreter.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-loweredcodeutils
+  (package
+    (name "julia-loweredcodeutils")
+    (version "0.3.6")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaDebug/LoweredCodeUtils.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "LoweredCodeUtils")
+	      (sha256
+	       (base32 "14lsm58s1swhywys7z05ly386c21w1gn0pdb87shmys99lmzg6ib"))))
+    (propagated-inputs `(("julia-juliainterpreter" ,julia-juliainterpreter)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaDebug/LoweredCodeUtils.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-revise
+  (package
+    (name "julia-revise")
+    (version "2.1.6")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/timholy/Revise.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Revise")
+	      (sha256
+	       (base32 "0qnfgsf4h13bw6jj6dd4559i00fdj8qbk8lmvrqx8qivb8b0ykxi"))))
+    (propagated-inputs `(("julia-loweredcodeutils" ,julia-loweredcodeutils)
+			 ("julia-juliainterpreter" ,julia-juliainterpreter)
+			 ("julia-orderedcollections" ,julia-orderedcollections)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/timholy/Revise.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-tableshowutils
+  (package
+    (name "julia-tableshowutils")
+    (version "0.2.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/TableShowUtils.jl.git")
+		    (commit "0515a2cc615d55c2c5412e8d84740ea01fa4f7aa")))
+	      (file-name "TableShowUtils")
+	      (sha256
+	       (base32 "1mbniba5llf4f0k57wwd2a0i5c77d1sry66xaz9h9w5b2lhx7cdy"))))
+    (propagated-inputs `(("julia-markdown" ,julia-markdown)
+			 ("julia-json" ,julia-json)
+			 ("julia-datavalues" ,julia-datavalues)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/TableShowUtils.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-iteratorinterfaceextensions
+  (package
+    (name "julia-iteratorinterfaceextensions")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/IteratorInterfaceExtensions.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "IteratorInterfaceExtensions")
+	      (sha256
+	       (base32 "1slpay1dhja8f9gy6z7b3psgvgcknn963dvfqqakvg1grk9ppa09"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/IteratorInterfaceExtensions.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-queryoperators
+  (package
+    (name "julia-queryoperators")
+    (version "0.9.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/QueryOperators.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "QueryOperators")
+	      (sha256
+	       (base32 "0bfwjahpcfmrp2z0gyj98nm1f19k1hqafz9znznb8yvn1rr58xm3"))))
+    (propagated-inputs `(("julia-datavalues" ,julia-datavalues)
+			 ("julia-datastructures" ,julia-datastructures)
+			 ("julia-tableshowutils" ,julia-tableshowutils)
+			 ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/QueryOperators.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-tabletraits
+  (package
+    (name "julia-tabletraits")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/TableTraits.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "TableTraits")
+	      (sha256
+	       (base32 "0lzb9xqnhgjbvkscc4p9vw3pzajm3a5a6ayv6byqc53ws8fxqk2v"))))
+    (propagated-inputs `(("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/TableTraits.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-tabletraitsutils
+  (package
+    (name "julia-tabletraitsutils")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/TableTraitsUtils.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "TableTraitsUtils")
+	      (sha256
+	       (base32 "0axmrznfmii7c909mcgr2zpzlddj62j1dhnss6d2gl9ar5mw5cl9"))))
+    (propagated-inputs `(("julia-datavalues" ,julia-datavalues)
+			 ("julia-tabletraits" ,julia-tabletraits)
+			 ("julia-missings" ,julia-missings)
+			 ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/TableTraitsUtils.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-iterabletables
+  (package
+    (name "julia-iterabletables")
+    (version "0.11.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/IterableTables.jl.git")
+		    (commit "2683c006134613131c1f747c0f0fa40ec6e49bf0")))
+	      (file-name "IterableTables")
+	      (sha256
+	       (base32 "1ifhlvrq16nki11pa6sqys9fna0v91659snp0x0y2sb1q2y2lv4g"))))
+    (propagated-inputs `(("julia-datavalues" ,julia-datavalues)
+			 ("julia-requires" ,julia-requires)
+			 ("julia-tabletraits" ,julia-tabletraits)
+			 ("julia-tabletraitsutils" ,julia-tabletraitsutils)
+			 ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/IterableTables.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-query
+(package
+(name "julia-query")
+(version "0.12.0")
+(source
+(origin
+(method git-fetch)
+(uri
+(git-reference
+(url "https://github.com/queryverse/Query.jl.git")
+(commit
+(string-append "v" version))))
+(file-name "Query")
+(sha256
+(base32 "19m87d5913mnk5vlfkkl9560dnsjn4c5k00aigrhpcgvv8ns0p07"))))
+(propagated-inputs
+`(("julia-macrotools" ,julia-macrotools)
+("julia-queryoperators" ,julia-queryoperators)
+("julia-iterabletables" ,julia-iterabletables)
+("julia-datavalues" ,julia-datavalues)))
+(build-system julia-build-system)
+(home-page "https://github.com/queryverse/Query.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-cairo
+  (package
+    (name "julia-cairo")
+    (version "0.6.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGraphics/Cairo.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Cairo")
+       (sha256
+	(base32 "1hrv8pxrywl1845wq697qqk0l41fjh06gvl9cfqhym1x04f3j9qj"))))
+    (propagated-inputs
+     `(("julia-graphics" ,julia-graphics)
+       ("julia-colors" ,julia-colors)
+       ("julia-bindeps" ,julia-bindeps)
+       ("julia-compat" ,julia-compat)
+       ("glib" ,glib)
+       ("cairo" ,cairo)
+       ("pango" ,pango)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda*
+	       (#:key outputs source inputs #:allow-other-keys)
+	     (let
+		 ((f
+		   (open-file
+		    (string-append
+		     (assoc-ref outputs "out")
+		     "/share/julia/packages/"
+		     (string-append
+		      (strip-store-file-name source)
+		      "/deps/deps.jl"))
+		    "w")))
+	       (display
+		(string-append "const _jl_libcairo = \""
+			       (assoc-ref inputs "cairo")
+			       "/lib/libcairo.so\"\n")
+		f)
+	       (display
+		(string-append "const _jl_libpango = \""
+			       (assoc-ref inputs "pango")
+			       "/lib/libpango-1.0.so\"\n")
+		f)
+	       (display
+		(string-append "const _jl_libpangocairo = \""
+			       (assoc-ref inputs "pango")
+			       "/lib/libpangocairo-1.0.so\"\n")
+		f)
+	       (display
+		(string-append "const _jl_libgobject = \""
+			       (assoc-ref inputs "glib")
+			       "/lib/libgobject-2.0.so\"\n")
+		f)
+	       (close-port f))
+	     #t)
+	   ))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/Cairo.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-gtk
+  (package
+    (name "julia-gtk")
+    (version "0.17.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGraphics/Gtk.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Gtk")
+       (sha256
+	(base32 "0ivvia2iq8mfqhyjf9bjw9p1wamzi69gsr8j7av9j1hk5xn7xxc5"))))
+    (propagated-inputs
+     `(("julia-bindeps" ,julia-bindeps)
+       ("julia-cairo" ,julia-cairo)
+       ("julia-reexport" ,julia-reexport)
+       ("julia-compat" ,julia-compat)
+       ("julia-graphics" ,julia-graphics)
+       ("glib" ,glib)
+       ("gtk+" ,gtk+)
+       ("gdk-pixbuf" ,gdk-pixbuf)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 ;; Precompilation tries to open display
+	 (delete 'precompile)
+	 (add-after 'install 'build-deps
+	   (lambda*
+	       (#:key outputs source inputs #:allow-other-keys)
+	     (substitute*
+		 (string-append
+		  (assoc-ref outputs "out")
+		  "/share/julia/packages/"
+		  (string-append
+		   (strip-store-file-name source)
+		   "/deps/ext_glib.jl"))
+	       (("\"libgobject-2.0\"")
+		(string-append "\""
+			       (assoc-ref inputs "glib")
+			       "/lib/libgobject-2.0.so\""))
+	       (("\"libglib-2.0\"")
+		(string-append "\""
+			       (assoc-ref inputs "glib")
+			       "/lib/libglib-2.0.so\"")))
+	     (substitute*
+		 (string-append
+		  (assoc-ref outputs "out")
+		  "/share/julia/packages/"
+		  (string-append
+		   (strip-store-file-name source)
+		   "/deps/ext.jl"))
+	       (("\"libgtk-3\"")
+		(string-append "\""
+			       (assoc-ref inputs "gtk+")
+			       "/lib/libgtk-3.so\""))
+	       (("\"libgdk-3\"")
+		(string-append "\""
+			       (assoc-ref inputs "gtk+")
+			       "/lib/libgtk-3.so\""))
+	       (("\"libgdk_pixbuf-2.0\"")
+		(string-append "\""
+			       (assoc-ref inputs "gdk-pixbuf")
+			       "/lib/libgdk_pixbuf-2.0.so\""))
+	       (("\"libgio-2.0\"")
+		(string-append "\""
+			       (assoc-ref inputs "glib")
+			       "/lib/libgio-2.0.so\"")))
+	     #t)))))
+    (home-page "https://github.com/JuliaGraphics/Gtk.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-hiccup
+  (package
+    (name "julia-hiccup")
+    (version "0.2.2")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JunoLab/Hiccup.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Hiccup")
+       (sha256
+	(base32 "0m6my7d48658x4v0glv1006f0yvqd49f875b74q7kq3y6a9sxy5z"))))
+    (propagated-inputs
+     `(("julia-macrotools" ,julia-macrotools)
+       ("julia-orderedcollections" ,julia-orderedcollections)
+       ("julia-lazy" ,julia-lazy)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JunoLab/Hiccup.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-websockets
+  (package
+    (name "julia-websockets")
+    (version "1.5.2")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaWeb/WebSockets.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "WebSockets")
+       (sha256
+	(base32 "1fpvskbax88x059lwnl211ps13j8s2jf97agwwr69sir11i0xh51"))))
+    (propagated-inputs
+     `(("julia-http" ,julia-http)
+       ("julia-requires" ,julia-requires)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/WebSockets.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-pidfile
+  (package
+    (name "julia-pidfile")
+    (version "1.1.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/vtjnash/Pidfile.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Pidfile")
+       (sha256
+	(base32 "16xyb8mybj90l40rcd49ii6id2xllr9lgrb6p6l0g1ggyballwcd"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/vtjnash/Pidfile.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-assetregistry
+  (package
+    (name "julia-assetregistry")
+    (version "0.1.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGizmos/AssetRegistry.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "AssetRegistry")
+       (sha256
+	(base32 "0xpldj08apvblgng6vndb9311gl6xxbk1f9jha8a661p2zfj0r4b"))))
+    (propagated-inputs
+     `(("julia-json" ,julia-json)
+       ("julia-sha" ,julia-sha)
+       ("julia-pidfile" ,julia-pidfile)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "AssetRegistry"
+	      "bf4720bc-e11a-5d0c-854e-bdca1663c893"
+	      "0.1.0"
+	      '(("SHA" . "ea8e919c-243c-51af-8825-aaa63cd721ce")
+		("JSON" . "682c06a0-de6a-54ab-a142-c8b1cf79cde6")
+		;; ("Pidfile" . "fa939f87-e72e-5be4-a000-7fc836dbe307")
+		))
+	     #t)))))
+    (home-page "https://github.com/JuliaGizmos/AssetRegistry.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-mux
+  (package
+    (name "julia-mux")
+    (version "0.7.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaWeb/Mux.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Mux")
+       (sha256
+	(base32 "1wmgh9iji0smx6vkn9y1kiylgci1ay0jrb968b61h6grwk9gxvlj"))))
+    (propagated-inputs
+     `(("julia-http" ,julia-http)
+       ("julia-hiccup" ,julia-hiccup)
+       ("julia-lazy" ,julia-lazy)
+       ("julia-websockets" ,julia-websockets)
+       ("julia-assetregistry" ,julia-assetregistry)
+       ("julia-parsers" ,julia-parsers)
+       ("julia-tokenize" ,julia-tokenize)
+       ("julia-datastructures" ,julia-datastructures)
+       ("julia-cstparser" ,julia-cstparser)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/Mux.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-observables
+  (package
+    (name "julia-observables")
+    (version "0.2.3")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGizmos/Observables.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Observables")
+       (sha256
+	(base32 "16qjjagaa6dvi3fhqyljhxg07r5cjz6d1h8yl38x3c11ilrvdy50"))))
+    (propagated-inputs
+     `())
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "Observables"
+	      "510215fc-4207-5dde-b226-833fc4488ee2"
+	      "0.2.3"
+	      '())
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGizmos/Observables.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-widgets
+  (package
+    (name "julia-widgets")
+    (version "0.6.1")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/piever/Widgets.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Widgets")
+       (sha256
+	(base32 "1w8rgaqprmz8g4kkjv2ba3hd66k5r62ra9p7j2bhrvvmw5h6dchp"))))
+    (propagated-inputs
+     `(("julia-observables" ,julia-observables)
+       ("julia-orderedcollections" ,julia-orderedcollections)
+       ("julia-colors" ,julia-colors)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "Widgets"
+	      "cc8bc4a8-27d6-5769-a93b-9d913e69aa62"
+	      "0.6.1"
+	      '())
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/piever/Widgets.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-functionalcollections
+  (package
+    (name "julia-functionalcollections")
+    (version "0.5.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaCollections/FunctionalCollections.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "FunctionalCollections")
+       (sha256
+	(base32 "1lvb7xaqg1w5cqq1z5jv4fcyagb2psq9k8i7k7n2pz1qf7rwfgcd"))))
+    (propagated-inputs
+     `())
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "FunctionalCollections"
+	      "de31a74c-ac4f-5751-b3fd-e18cd04993ca"
+	      "0.5.0"
+	      '())
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaCollections/FunctionalCollections.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-webio
+  (package
+    (name "julia-webio")
+    (version "0.8.8")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGizmos/WebIO.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "WebIO")
+       (sha256
+	(base32 "0w0jqkkm9m4h9inkjhjm69y8fbvvqvmcyaszm7y5md8a2xyc392w"))))
+    (propagated-inputs
+     `(("julia-widgets" ,julia-widgets)
+       ("julia-compat" ,julia-compat)
+       ("julia-json" ,julia-json)
+       ("julia-observables" ,julia-observables)
+       ("julia-functionalcollections" ,julia-functionalcollections)
+       ("julia-requires" ,julia-requires)
+       ("julia-websockets" ,julia-websockets)
+       ("julia-assetregistry" ,julia-assetregistry)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGizmos/WebIO.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-jsexpr
+  (package
+    (name "julia-jsexpr")
+    (version "0.5.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGizmos/JSExpr.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "JSExpr")
+       (sha256
+	(base32 "0zdjfg2312z7gcrrl60nhx7l0krdj8bk8kk8x1qy4hyx486dp1lv"))))
+    (propagated-inputs
+     `(("julia-observables" ,julia-observables)
+       ("julia-macrotools" ,julia-macrotools)
+       ("julia-json" ,julia-json)
+       ("julia-webio" ,julia-webio)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "JSExpr"
+	      "97c1335a-c9c5-57fe-bc5d-ec35cebe8660"
+	      "0.5.0"
+	      '())
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGizmos/JSExpr.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-knockout
+  (package
+    (name "julia-knockout")
+    (version "0.2.3")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGizmos/Knockout.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Knockout")
+       (sha256
+	(base32 "1kwr982n0789yqgq1wdrx8lz4h5c58wldgzfn6am87fllkgbna5l"))))
+    (propagated-inputs
+     `(("julia-json" ,julia-json)
+       ("julia-jsexpr" ,julia-jsexpr)
+       ("julia-observables" ,julia-observables)
+       ("julia-webio" ,julia-webio)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGizmos/Knockout.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-cssutil
+  (package
+    (name "julia-cssutil")
+    (version "0.1.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGizmos/CSSUtil.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "CSSUtil")
+       (sha256
+	(base32 "1dvlwkpbjwwggyx5sh3645sz02yd9h067pcymcam5k4sprx4qdwx"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)
+       ("julia-measures" ,julia-measures)
+       ("julia-json" ,julia-json)
+       ("julia-colors" ,julia-colors)
+       ("julia-webio" ,julia-webio)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "CSSUtil"
+	      "70588ee8-6100-5070-97c1-3cb50ed05fe8"
+	      "0.1.0"
+	      '())
+	     #t)))))
+    (home-page "https://github.com/JuliaGizmos/CSSUtil.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-interactbase
+  (package
+    (name "julia-interactbase")
+    (version "0.10.2")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/piever/InteractBase.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "InteractBase")
+       (sha256
+	(base32 "0jiw93s8cqwbp7nhdmbhp9xn76an81h9yyyfq6mhiwxkcdhnm213"))))
+    (propagated-inputs
+     `(("julia-json" ,julia-json)
+       ("julia-knockout" ,julia-knockout)
+       ("julia-jsexpr" ,julia-jsexpr)
+       ("julia-colors" ,julia-colors)
+       ("julia-orderedcollections" ,julia-orderedcollections)
+       ("julia-widgets" ,julia-widgets)
+       ("julia-observables" ,julia-observables)
+       ("julia-cssutil" ,julia-cssutil)
+       ("julia-webio" ,julia-webio)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/piever/InteractBase.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-interact
+  (package
+    (name "julia-interact")
+    (version "0.10.2")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGizmos/Interact.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Interact")
+       (sha256
+	(base32 "0jin1ym3k48z1cxy7sq94cvm95hc19lsh7r5cjfmcji1yahgbn3p"))))
+    (propagated-inputs
+     `(("julia-observables" ,julia-observables)
+       ("julia-reexport" ,julia-reexport)
+       ("julia-orderedcollections" ,julia-orderedcollections)
+       ("julia-json" ,julia-json)
+       ("julia-interactbase" ,julia-interactbase)
+       ("julia-widgets" ,julia-widgets)
+       ("julia-knockout" ,julia-knockout)
+       ("julia-cssutil" ,julia-cssutil)
+       ("julia-webio" ,julia-webio)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGizmos/Interact.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-json2
+  (package
+    (name "julia-json2")
+    (version "0.3.1")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/quinnj/JSON2.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "JSON2")
+       (sha256
+	(base32 "1hc3pwjxka206fd69x8dmdg11nnxand9bxbhs0lf3pzdhpf81jna"))))
+    (propagated-inputs
+     `(("julia-parsers" ,julia-parsers)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/quinnj/JSON2.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-msgpack
+  (package
+    (name "julia-msgpack")
+    (version "0.2.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaIO/MsgPack.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "MsgPack")
+       (sha256
+	(base32 "1dvy8bhkf6gjp8fsxl5g85jhjdngizwln9iklgrnvf5rm0nc7y18"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/MsgPack.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-osc
+  (package
+    (name "julia-osc")
+    (version "0.1.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://git.nixo.xyz/nixo/OSC.jl.git")
+	 (commit "d18aceff140021e7eb961b5b42d17c23e64074a4")))
+       (file-name "OSC")
+       (sha256
+	(base32 "11npby13nsw3qcjlwa7m20pzfnb43kvax5arjdgdm7mmlzm1wi32"))))
+    (propagated-inputs
+     `())
+    (build-system julia-build-system)
+    (home-page "https://git.nixo.xyz/nixo/OSC.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-reactive
+  (package
+    (name "julia-reactive")
+    (version "0.8.3")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGizmos/Reactive.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Reactive")
+       (sha256
+	(base32 "0a5s1axxdqkvi1w375h215jjmmyq72a0pyjqrbpvr1zikplmzwdc"))))
+    (propagated-inputs
+     `(("julia-datastructures" ,julia-datastructures)
+       ("julia-compat" ,julia-compat)
+       ;; ("julia-factcheck" ,julia-factcheck)
+       ))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGizmos/Reactive.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-intervalsets
+  (package
+    (name "julia-intervalsets")
+    (version "0.3.1")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaMath/IntervalSets.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "IntervalSets")
+       (sha256
+	(base32 "0f0ss4zwhphihmgq037qqva1knknvj2mqs26xzpg3wvvv2rzd9sb"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaMath/IntervalSets.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-roundingintegers
+  (package
+    (name "julia-roundingintegers")
+    (version "0.2.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaMath/RoundingIntegers.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "RoundingIntegers")
+       (sha256
+	(base32 "0g8avl67181q29vnza1gmmc3hj183jqknvi4daryj49313z0whj3"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaMath/RoundingIntegers.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-gtkreactive
+;;   (package
+;;     (name "julia-gtkreactive")
+;;     (version "0.6.0")
+;;     (source
+;;      (origin
+;;        (method git-fetch)
+;;        (uri
+;; 	(git-reference
+;; 	 (url "https://github.com/JuliaGizmos/GtkReactive.jl.git")
+;; 	 (commit
+;; 	  (string-append "v" version))))
+;;        (file-name "GtkReactive")
+;;        (sha256
+;; 	(base32 "0s37jdjnsp299drmrj2wa7zp89pnnh44ql6sxy59mq10wjjhmhj7"))))
+;;     (propagated-inputs
+;;      `(("julia-reactive" ,julia-reactive)
+;;        ("julia-intervalsets" ,julia-intervalsets)
+;;        ("julia-cairo" ,julia-cairo)
+;;        ("julia-colors" ,julia-colors)
+;;        ("julia-roundingintegers" ,julia-roundingintegers)
+;;        ("julia-reexport" ,julia-reexport)
+;;        ("julia-graphics" ,julia-graphics)
+;;        ("julia-gtk" ,julia-gtk)
+;;        ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaGizmos/GtkReactive.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-zmq
+      (package
+	(name "julia-zmq")
+	(version "1.0.0")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/JuliaInterop/ZMQ.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "ZMQ")
+	          (sha256
+                   (base32 "0lfcq0xdw55silqy47hfsm81418agxxr8qly4sx9lpa9f3js12pz"))))
+	(propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
+			     ("julia-compat" ,julia-compat)
+			     ("zeromq" ,zeromq)))
+	(arguments
+	 `(#:phases
+	   (modify-phases %standard-phases
+	     (add-before 'precompile 'build-deps
+	       (lambda* (#:key outputs source inputs #:allow-other-keys)
+		 (let ((f (open-file
+			   (string-append
+			    (assoc-ref outputs "out")
+			    "/share/julia/packages/"
+			    (string-append
+			     (strip-store-file-name source) "/deps/deps.jl"))
+			   "w")))
+		   (display (string-append "const libzmq = \""
+					   (assoc-ref inputs "zeromq")
+					   "/lib/libzmq.so\"\n") f) 
+		   (display (string-append "check_deps() = nothing\n") f)
+		   (close-port f))
+		 #t)
+	       )
+	     (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "ZMQ"
+	      "c2297ded-f4af-51ae-bb23-16f91089e4e1"
+	      "1.0.0"
+	      '(("Libdl" . "8f399da3-3557-5675-b5ff-fb832c97cbdb")
+		("FileWatching" . "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee")
+		("Sockets" . "6462fe0b-24de-5631-8697-dd941f90decc")))
+	     #t)))))
+	(build-system julia-build-system)
+	(home-page "https://github.com/JuliaInterop/ZMQ.jl.git")
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-softglobalscope
+      (package
+	(name "julia-softglobalscope")
+	(version "1.0.10")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/stevengj/SoftGlobalScope.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "SoftGlobalScope")
+	          (sha256
+                   (base32 "1h6cka2iv4x21nnjyn4j0zizi7km75m6xvz2imih6gyjmq9hqlnp"))))
+	(propagated-inputs `())
+	(arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "SoftGlobalScope"
+	      "b85f4697-e234-5449-a836-ec8e2f98b302"
+	      "1.0.10"
+	      '())
+	     #t)))))
+	(build-system julia-build-system)
+	(home-page "https://github.com/stevengj/SoftGlobalScope.jl.git")
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-versionparsing
+      (package
+	(name "julia-versionparsing")
+	(version "1.1.3")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/stevengj/VersionParsing.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "VersionParsing")
+	          (sha256
+                   (base32 "09bkzw21yyhvnknk6cs96j4ydb05fzppyhx0qgl5fqijsbn8dwqk"))))
+	(propagated-inputs `(("julia-compat" ,julia-compat)))
+	(build-system julia-build-system)
+	(home-page "https://github.com/stevengj/VersionParsing.jl.git")
+	(arguments
+	 `(#:phases
+	   (modify-phases %standard-phases
+	     (add-before 'precompile 'fix-toml
+	       (lambda*
+		   (#:key outputs source #:allow-other-keys)
+		 (julia-create-package-toml
+		  outputs source
+		  "VersionParsing"
+		  "81def892-9a0e-5fdd-b105-ffc91e053289"
+		  "1.1.3"
+		  '())
+		 #t)))))
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+;; (define-public julia-conda
+;;       (package
+;;        (name "julia-conda")
+;;        (version "1.3.0")
+;;        (source (origin
+;; 	        (method git-fetch)
+;; 	        (uri (git-reference
+;; 		      (url "https://github.com/JuliaPy/Conda.jl.git")
+;; 		      (commit (string-append "v" version))))
+;; 	        (file-name "Conda")
+;; 	        (sha256
+;;                  (base32 "1zckglwgr7vd02rzgpshf0jqsfjby2vk8xvaxj68056pkw529ia2"))))
+;;        (propagated-inputs `(("julia-bindeps" ,julia-bindeps)
+;; 			    ("julia-json" ,julia-json)
+;; 			    ("julia-versionparsing" ,julia-versionparsing)))
+;;        (build-system julia-build-system)
+;;        (home-page "https://github.com/JuliaPy/Conda.jl.git")
+;;        (synopsis "")
+;;        (description "")
+;;        (license license:expat)))
+
+;; (define-public julia-ijulia
+;;   (package
+;;     (name "julia-ijulia")
+;;     (version "1.19.0")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaLang/IJulia.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "IJulia")
+;; 	      (sha256
+;; 	       (base32 "0ygqkl7gn9d8ypplbha9hrn42357mjygl9xc3aq1va5h2pb2740a"))))
+;;     (propagated-inputs `(("julia-zmq" ,julia-zmq)
+;; 			 ("julia-json" ,julia-json)
+;; 			 ("julia-mbedtls" ,julia-mbedtls)
+;; 			 ("julia-markdown" ,julia-markdown)
+;; 			 ("julia-softglobalscope" ,julia-softglobalscope)
+;; 			 ("julia-conda" ,julia-conda)
+;; 			 ("jupyter" ,jupyter)))
+;;     (build-system julia-build-system)
+;;     (arguments
+;;      `(#:phases
+;;        (modify-phases %standard-phases
+;; 	 (add-after 'install 'build-deps
+;; 	   (lambda* (#:key outputs source inputs #:allow-other-keys)
+;; 	     (let ((f (open-file
+;; 		       (string-append
+;; 			(assoc-ref outputs "out")
+;; 			"/share/julia/packages/"
+;; 			(string-append
+;; 			 (strip-store-file-name source) "/deps/deps.jl"))
+;; 		       "w")))
+;; 	       (display (string-append
+;; 			 "
+;; const IJULIA_DEBUG = false
+;; const JUPYTER = \""
+;; 			 (assoc-ref inputs "jupyter")
+;; 			 "/bin/jupyter\"")
+;; 			f)
+;; 	       (close-port f))
+;; 	     #t))
+;; 	 ;; debug
+;; 	 (delete 'precompile))))
+;;     (home-page "https://github.com/JuliaLang/IJulia.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+
+(define-public julia-glm
+  (package
+    (name "julia-glm")
+    (version "1.3.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaStats/GLM.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "GLM")
+	      (sha256
+	       (base32 "03skzihlvyy76qal1chhz3jfxilg556k9iwk23zzihd46i6z2par"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaStats/GLM.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-formatting
+      (package
+       (name "julia-formatting")
+       (version "0.3.5")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/JuliaIO/Formatting.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "Formatting")
+	        (sha256
+                 (base32 "0nrdacmczf7xn1g8g3acampk0w5hal8cwfh16y96hi3zbfycxhx9"))))
+       (propagated-inputs `(("julia-compat" ,julia-compat)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaIO/Formatting.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-namedcolors
+      (package
+       (name "julia-namedcolors")
+       (version "0.2.0")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/JuliaGraphics/NamedColors.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "NamedColors")
+	        (sha256
+                 (base32 "13n68gdl51g7md0hfxs3ckpwb1ngvjwgngqcadg3dalir9q8ldyf"))))
+       (propagated-inputs `(("julia-colortypes" ,julia-colortypes)
+			    ("julia-colors" ,julia-colors)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaGraphics/NamedColors.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-codecs
+      (package
+       (name "julia-codecs")
+       (version "0.5.0")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/BioJulia/Codecs.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "Codecs")
+	        (sha256
+                 (base32 "1i4xg0f75gidxmsim0as7s18sb7g4mxb04513025vb1433vvvcni"))))
+       (propagated-inputs `())
+       (build-system julia-build-system)
+       (home-page "https://github.com/BioJulia/Codecs.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-yaml
+      (package
+       (name "julia-yaml")
+       (version "0.3.2")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/BioJulia/YAML.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "YAML")
+	        (sha256
+                 (base32 "1csrkk7q5m2mw3znbkn7j8dqhxx7innam2gcll2qmw7paq03gzwr"))))
+       (propagated-inputs `(("julia-codecs" ,julia-codecs)
+("julia-compat" ,julia-compat)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/BioJulia/YAML.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-abstracttrees
+      (package
+       (name "julia-abstracttrees")
+       (version "0.2.1")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/Keno/AbstractTrees.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "AbstractTrees")
+	        (sha256
+                 (base32 "0w05zar1hlyqqx7zlzh05h78mjs9vsgaifn5z390crrhb1bgw4bj"))))
+       (propagated-inputs `(("julia-compat" ,julia-compat)
+			    ;; ("julia-markdown" ,julia-markdown)
+			    ))
+       (build-system julia-build-system)
+       (home-page "https://github.com/Keno/AbstractTrees.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-gumbo
+  (package
+    (name "julia-gumbo")
+    (version "0.5.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaWeb/Gumbo.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Gumbo")
+	      (sha256
+	       (base32 "1wsdrqz3jj684paanmpla9kvpdcv7sbsw2967kljykvb4plvsx95"))))
+    (propagated-inputs `(("julia-sha" ,julia-sha)
+			 ("julia-abstracttrees" ,julia-abstracttrees)
+			 ("julia-binaryprovider" ,julia-binaryprovider)
+			 ("julia-compat" ,julia-compat)
+			 ("gumbo-parser", gumbo-parser)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda* (#:key outputs source inputs #:allow-other-keys)
+	     (let ((f (open-file
+		       (string-append
+			(assoc-ref outputs "out")
+			"/share/julia/packages/"
+			(string-append
+			 (strip-store-file-name source) "/deps/deps.jl"))
+		       "w")))
+	       (display (string-append "const libgumbo = \""
+				       (assoc-ref inputs "gumbo-parser")
+				       "/lib/libgumbo.so\"\n") f)
+	       (close-port f))
+	     #t)
+	   ))))
+
+    (home-page "https://github.com/JuliaWeb/Gumbo.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-cascadia
+  (package
+    (name "julia-cascadia")
+    (version "0.4.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/Algocircle/Cascadia.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Cascadia")
+	      (sha256
+	       (base32 "0jfz2p94y9l62fa6si9hfb7czhj26i9n1p7gzb9vz1x32v2q2gdp"))))
+    (propagated-inputs `(("julia-gumbo" ,julia-gumbo)
+			 ("julia-abstracttrees" ,julia-abstracttrees)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/Algocircle/Cascadia.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-fileio
+  (package
+    (name "julia-fileio")
+    (version "1.0.7")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaIO/FileIO.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "FileIO")
+	      (sha256
+	       (base32 "0dwsklxzc4nhsii9hhjp1h3cbf9n5abipj44jf3i0zncid06aanv"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)
+			 ;; ("julia-docile" ,julia-docile)
+			 ))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/FileIO.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-transcodingstreams
+      (package
+       (name "julia-transcodingstreams")
+       (version "0.9.4")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/bicycle1885/TranscodingStreams.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "TranscodingStreams")
+	        (sha256
+                 (base32 "0dgn8kqh4qlym3bicdblp9rsg1kqlwlnl22ik75dfwwqbzpnaf0m"))))
+       (propagated-inputs `(("julia-compat" ,julia-compat)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/bicycle1885/TranscodingStreams.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-codeczlib
+  (package
+    (name "julia-codeczlib")
+    (version "0.5.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/bicycle1885/CodecZlib.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CodecZlib")
+	      (sha256
+               (base32 "0v3n3fk7iaslqjyy7qxbad4yzfsd8cq8qdr8is6f79l90nwg8d92"))))
+    (propagated-inputs `(("julia-transcodingstreams" ,julia-transcodingstreams)
+			 ("julia-binaryprovider" ,julia-binaryprovider)
+			 ("zlib" ,zlib)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda* (#:key outputs source inputs #:allow-other-keys)
+	     (let ((f (open-file
+		       (string-append
+			(assoc-ref outputs "out")
+			"/share/julia/packages/"
+			(string-append
+			 (strip-store-file-name source) "/deps/deps.jl"))
+		       "w")))
+	       (display (string-append "const libz = \""
+				       (assoc-ref inputs "zlib")
+				       "/lib/libz.so\"\n") f)
+	       (display "check_deps() = true\n" f)
+	       (close-port f))
+	     #t))
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "CodecZlib"
+	      "944b1d66-785c-5afd-91f1-9de20f533193"
+	      "0.5.2"
+	      '())
+	     #t))
+	 )))
+    (build-system julia-build-system)
+    (home-page "https://github.com/bicycle1885/CodecZlib.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-nullables
+  (package
+    (name "julia-nullables")
+    (version "0.0.8")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaAttic/Nullables.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Nullables")
+	      (sha256
+               (base32 "00mdnk5hrl04wyw7g8dwybnxzn2wh0l52pa7398l3wggak2iqx1b"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "Nullables"
+	      "4d1e1d77-625e-5b40-9113-a560ec7a8ecd"
+	      "0.0.8"
+	      '())
+	     #t))
+	 )))
+    (home-page "https://github.com/JuliaAttic/Nullables.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-specialfunctions
+      (package
+	(name "julia-specialfunctions")
+	(version "0.7.2")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/JuliaMath/SpecialFunctions.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "SpecialFunctions")
+	          (sha256
+                   (base32 "168jhv4b4n1vfzv7qrxxgx5jvc60lsgd2f6jrki4r0i9nfis81yq"))))
+	(propagated-inputs `(("julia-bindeps" ,julia-bindeps)
+			     ("julia-binaryprovider" ,julia-binaryprovider)
+			     ("openspecfun" ,openspecfun)))
+       (arguments
+	 `(#:phases
+	   (modify-phases %standard-phases
+	     (add-before 'precompile 'build-deps
+	       (lambda* (#:key outputs source inputs #:allow-other-keys)
+		 (let ((f (open-file
+			   (string-append
+			    (assoc-ref outputs "out")
+			    "/share/julia/packages/"
+			    (string-append
+			     (strip-store-file-name source) "/deps/deps.jl"))
+			   "w")))
+		   (display (string-append "const openspecfun = \""
+					   (assoc-ref inputs "openspecfun")
+					   "/lib/libopenspecfun.so\"\n") f)
+		   (display "check_deps() = true\n" f)
+		   (close-port f))
+		 #t)))))
+	(build-system julia-build-system)
+	(home-page "https://github.com/JuliaMath/SpecialFunctions.jl.git")
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-quadmath
+      (package
+       (name "julia-quadmath")
+       (version "0.5.0")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/JuliaMath/Quadmath.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "Quadmath")
+	        (sha256
+                 (base32 "0s3y16713cs3zwzypdsnl9c7dlilcln039mnypxcnbxss7lxkrfj"))))
+       (propagated-inputs `(("julia-requires" ,julia-requires)
+			    ("julia-specialfunctions" ,julia-specialfunctions)
+			    ))
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaMath/Quadmath.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-polynomials
+      (package
+	(name "julia-polynomials")
+	(version "0.5.2")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/JuliaMath/Polynomials.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "Polynomials")
+	          (sha256
+                   (base32 "1d7bmkj3a11g1diqqw9fynfw44wqhh8j1wssij63zn8pnlgh7b04"))))
+	(propagated-inputs `())
+	(build-system julia-build-system)
+	(home-page "https://github.com/JuliaMath/Polynomials.jl.git")
+	(arguments
+	 `(#:phases
+	   (modify-phases %standard-phases
+	     (add-before 'precompile 'fix-toml
+	       (lambda*
+		   (#:key outputs source #:allow-other-keys)
+		 (julia-create-package-toml
+		  outputs source
+		  "Polynomials"
+		  "f27b6e38-b328-58d1-80ce-0feddd5e7a45"
+		  "0.5.2"
+		  '())
+		 #t)))))
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-genericschur
+      (package
+       (name "julia-genericschur")
+       (version "0.2.3")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/RalphAS/GenericSchur.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "GenericSchur")
+	        (sha256
+                 (base32 "1yd91zqfwkknvcpfkzxpmyikp2m6z6f6gvlpa0qxhyc96657m6ah"))))
+       (propagated-inputs `())
+       (build-system julia-build-system)
+       (home-page "https://github.com/RalphAS/GenericSchur.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-genericsvd
+      (package
+	(name "julia-genericsvd")
+	(version "0.2.1")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/JuliaLinearAlgebra/GenericSVD.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "GenericSVD")
+	          (sha256
+                   (base32 "0icdfyipvhy3dnq7yri3cg3mr0szii1jgfqcb0fs8g7a9fcrd0a3"))))
+	(propagated-inputs `(("julia-compat" ,julia-compat)))
+	(arguments
+	 `(#:phases
+	   (modify-phases %standard-phases
+	     (add-before 'precompile 'fix-toml
+	       (lambda*
+		   (#:key outputs source #:allow-other-keys)
+		 (julia-create-package-toml
+		  outputs source
+		  "GenericSVD"
+		  "01680d73-4ee2-5a08-a1aa-533608c188bb"
+		  "0.2.1"
+		  '())
+		 #t)))))
+	(build-system julia-build-system)
+	(home-page "https://github.com/JuliaLinearAlgebra/GenericSVD.jl.git")
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-doublefloats
+      (package
+       (name "julia-doublefloats")
+       (version "0.9.3")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/JuliaMath/DoubleFloats.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "DoubleFloats")
+	        (sha256
+                 (base32 "0h39i29v2wqqmvbnphjmlarydpvgn17ayl7qipwh23qq2qm5lcqn"))))
+       (propagated-inputs `(("julia-quadmath" ,julia-quadmath)
+("julia-requires" ,julia-requires)
+("julia-polynomials" ,julia-polynomials)
+("julia-genericschur" ,julia-genericschur)
+("julia-genericsvd" ,julia-genericsvd)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaMath/DoubleFloats.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-weakrefstrings
+      (package
+       (name "julia-weakrefstrings")
+       (version "0.6.1")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/JuliaData/WeakRefStrings.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "WeakRefStrings")
+	        (sha256
+                 (base32 "00sfqhw2niarfmpn8i3dmv5dfhyj3bylvwp4yrq77b560g997khh"))))
+       (propagated-inputs `())
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaData/WeakRefStrings.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-textparse
+  (package
+    (name "julia-textparse")
+    (version "0.9.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaComputing/TextParse.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "TextParse")
+	      (sha256
+	       (base32 "1vzmn4gfhicif5vhzz0h3mv1qgpsmjfq4rz7rhbmkdqbwjfphfw2"))))
+    (propagated-inputs `(("julia-nullables" ,julia-nullables)
+			 ("julia-codeczlib" ,julia-codeczlib)
+			 ("julia-doublefloats" ,julia-doublefloats)
+			 ("julia-weakrefstrings" ,julia-weakrefstrings)
+			 ("julia-pooledarrays" ,julia-pooledarrays)
+			 ("julia-datastructures" ,julia-datastructures)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaComputing/TextParse.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-csvfiles
+  (package
+    (name "julia-csvfiles")
+    (version "0.15.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/CSVFiles.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CSVFiles")
+	      (sha256
+	       (base32 "1vzd6b1kp9gjml484lgziibkqasl5v83afr2yxaccskvmq36gxrm"))))
+    (propagated-inputs `(("julia-codeczlib" ,julia-codeczlib)
+			 ("julia-iterabletables" ,julia-iterabletables)
+			 ("julia-fileio" ,julia-fileio)
+			 ("julia-textparse" ,julia-textparse)
+			 ("julia-datavalues" ,julia-datavalues)
+			 ("julia-tabletraitsutils" ,julia-tabletraitsutils)
+			 ("julia-tabletraits" ,julia-tabletraits)
+			 ("julia-tableshowutils" ,julia-tableshowutils)
+			 ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
+			 ("julia-http" ,julia-http)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/CSVFiles.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-sqlite
+  (package
+    (name "julia-sqlite")
+    (version "0.8.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaDatabases/SQLite.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "SQLite")
+	      (sha256
+	       (base32 "0kpg0j9wd99qjlxvcr4zl5lm1d993j3php67dsvrrd9m2iva3i7v"))))
+    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
+			 ("julia-json" ,julia-json)
+			 ("julia-tables" ,julia-tables)
+			 ("julia-weakrefstrings" ,julia-weakrefstrings)
+			 ("julia-dataframes" ,julia-dataframes)
+			 ("sqlite" ,sqlite)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'build-deps
+	   (lambda* (#:key outputs source inputs #:allow-other-keys)
+	     (let ((f (open-file
+		       (string-append
+			(assoc-ref outputs "out")
+			"/share/julia/packages/"
+			(string-append
+			 (strip-store-file-name source) "/deps/deps.jl"))
+		       "w")))
+	       (display (string-append "const libsqlite = \""
+				       (assoc-ref inputs "sqlite")
+				       "/lib/libsqlite3.so\"\n") f)
+	       (display "check_deps() = true\n" f)
+	       (close-port f))
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaDatabases/SQLite.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
-- 
2.22.0