# Emacs-based workflow

**URL:** <https://discourse.julialang.org/t/emacs-based-workflow/19400>\
**Category:** Tooling\
**Tags:** emacs\
**Created:** [January 8, 2019, 10:13pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400 "2019-01-08T22:13:34Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![ffevotte](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ffevotte/32/6587_2.png) [@ffevotte](https://discourse.julialang.org/u/ffevotte)\
**Post date:** [January 8, 2019, 10:13pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/1 "2019-01-08T22:13:34Z")

</div>

I’m trying to set-up an (efficient) Emacs-based workflow to develop Julia code (on a linux system).

Currently, here is what I’m using:

- I have a live Julia REPL in an `ansi-term` buffer, which uses `Revise` to update the Julia code as I edit source files. I’m currently using my own [isend-mode](https://github.com/ffevotte/isend-mode.el) package to interact with this buffer and evaluate Julia code blocks, but am thinking of trying @Tamas_Papp’s [julia-repl](https://github.com/tpapp/julia-repl) instead1.

- In order to search for something in the documentation, I use [zeal](https://zealdocs.org/) and [zeal-at-point](https://github.com/jinzhu/zeal-at-point). But I don’t like spawning an external process (and window), especially when most of this documentation (and more) is available from Julia itself in a form that could easily be browsed within Emacs (but I haven’t found any readily-available tool to do this).

- In order to search for and (jump to) function definitions, I’m using [InteractiveCodeSearch.jl](https://github.com/tkf/InteractiveCodeSearch.jl). Again, I’d like to streamline the process of looking for the definition of the function at point (which I don’t think would be too difficult; I might try to develop a package to do it if I get around to it…)

Some of the points bothering me might very well be fixed by `LanguageServer` and [lsp-mode](https://github.com/emacs-lsp/lsp-mode), but I haven’t been able to successfully set these up yet. I had difficulties installing `LanguageServer`, and then had some trouble with `lsp-julia`2. In your opinion, is it worth to invest some time to make it work?

  

On another note, one thing I lack is the ability to quickly run tests. In most other languages (like C++ or Python), I would set up [compilation commands](https://www.gnu.org/software/emacs/manual/html_node/emacs/Compilation.html) to build and/or test my program, and bind them to a single key so that I can speed-up development cycles. In Julia, I use the same technique to run thorough tests (as in `julia -O3 --project runtests.jl`), but long startup times prevent me from running these too often. Most of the time, I simply go to the REPL and hit upRET. But I don’t like this process very much, since it sometimes interferes with other experiments I made in the REPL (and e.g. the last command is not what I thought it would be).

  

Have I blatantly missed anything? Do you (Emacs users) have entirely different workflows? Are you facing some of the same issues?

  

* * *

1 in particular, `julia-repl`’s use of bracketed paste might solve some quirks I have with `isend-mode` when sending indented blocks.

2 I tried to use @gdkrmr’s fork of [lsp-julia](https://github.com/gdkrmr/lsp-julia) (which seemed to be the most up-to-date) and had strange Emacs errors. At first sight, it looked like these might be due to incompatibilities between recent `lsp-mode` versions and my outdated Emacs-25; I’ll have to investigate.

---

<div class="post-metadata">

**Author:** ![non-Jedi](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/non-jedi/32/3645_2.png) [@non-Jedi](https://discourse.julialang.org/u/non-Jedi)\
**Post date:** [January 8, 2019, 10:23pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/2 "2019-01-08T22:23:03Z")

</div>

> [@ffevotte](#):
>
> I have a live Julia REPL in an `ansi-term` buffer, which uses `Revise` to update the Julia code as I edit source files. I’m currently using my own [isend-mode](https://github.com/ffevotte/isend-mode.el) package to interact with this buffer and evaluate Julia code blocks, but am thinking of trying @Tamas_Papp’s [julia-repl](https://github.com/tpapp/julia-repl) instead1.

I’ve been using [this interface to jupyter](https://github.com/dzop/emacs-jupyter) for my Julia REPL for the past several months, and it’s been lovely. There’s actually some julia-specific code in the repo to make Julia’s REPL a bit more friendly rather than just a generic jupyter prompt like provided by e.g. ob-ipython.

> [@ffevotte](#):
>
> 2 I tried to use @gdkrmr’s fork of [lsp-julia](https://github.com/gdkrmr/lsp-julia) (which seemed to be the most up-to-date) and had strange Emacs errors. At first sight, it looked like these might be due to incompatibilities between recent `lsp-mode` versions and my outdated Emacs-25; I’ll have to investigate.

I hope to update my fork some time in the coming few weeks and then maybe even publish to Melpa; just fyi.

> [@ffevotte](#):
>
> In Julia, I use the same technique to run thorough tests (as in `julia -O3 --project runtests.jl` ), but long startup times prevent me from running these too often. Most of the time, I simply go to the REPL and hit upRET. But I don’t like this process very much, since it sometimes interferes with other experiments I made in the REPL (and e.g. the last command is not what I thought it would be).

Startup times for just Julia have gotten pretty darn fast. It’s re-precompiling the package that probably takes all the time. But this would be no different than running `] test` in the REPL, so if you find that sufficient other than messing up your REPL session, binding running tests with the Julia binary to a key shouldn’t be any worse (as long as it’s an async command).

---

<div class="post-metadata">

**Author:** ![ffevotte](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ffevotte/32/6587_2.png) [@ffevotte](https://discourse.julialang.org/u/ffevotte)\
**Post date:** [January 8, 2019, 11:27pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/3 "2019-01-08T23:27:13Z")

</div>

> [@non-Jedi](#):
>
> I’ve been using [this interface to jupyter](https://github.com/dzop/emacs-jupyter) for my Julia REPL for the past several months, and it’s been lovely.

Thanks, I’ll definitely try this!

> [@non-Jedi](#):
>
> Startup times for just Julia have gotten pretty darn fast. It’s re-precompiling the package that probably takes all the time. But this would be no different than running `] test` in the REPL, so if you find that sufficient other than messing up your REPL session, binding running tests with the Julia binary to a key shouldn’t be any worse (as long as it’s an async command).

Yes, sorry if I was unclear. I do run extensive tests (like the full test suite) from a `M-x (re)compile` command, and it is as fast to run them this way (with a fresh julia process) as from `] test`. And I usually don’t care about how long it takes Julia to re-compile the necessary modules, since the tests themselves are long and there is potentially many of them.

What I meant is that when I’m working on a single function (o small part of the code), I like having a small test case to see whether I’m improving things or not (and at that time, I’m not necessarily interested in knowing whether I broke something else, which is what the full test suite is useful for). This “small test” is usually a single expression like

```julia
@btime myfun($testArg)

```

and I like to be able to run it right away (for now, in a “hot” REPL, relying on `Revise` to ensure that an up-to-date version of the code is run).

One thing I have in mind would be to have an “interactive” REPL open in a terminal where I can interact at will, and another REPL in a hidden/buried terminal buffer for “automated” interactions. I would not type directly in that second terminal, but would rather have small commands (bound to readily accessible keys) to send some pre-defined expression to the REPL. But that sounds an awful lot like I would then be re-inventing a poor-man’s LSP 😕

---

<div class="post-metadata">

**Author:** ![gdkrmr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gdkrmr/32/2791_2.png) [@gdkrmr](https://discourse.julialang.org/u/gdkrmr)\
**Post date:** [January 9, 2019, 1:31pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/4 "2019-01-09T13:31:50Z")

</div>

> [@ffevotte](#):
>
> 2 I tried to use @gdkrmr’s fork of [lsp-julia](https://github.com/gdkrmr/lsp-julia) (which seemed to be the most up-to-date) and had strange Emacs errors. At first sight, it looked like these might be due to incompatibilities between recent `lsp-mode` versions and my outdated Emacs-25; I’ll have to investigate.

I also get error messages in the `*Message*` buffer, but they are not fatal, you can see a discussion [here](https://github.com/syl20bnr/spacemacs/pull/11723)

I am using `spacemacs` with the `julia`-layer and everything works pretty well. There are currently some issues:

- There was no `LanguageServer.jl` release for Julia 1.0. Solved with release `v0.5.0`.
- There are breaking changes in the last release of `lsp-mode` and you have to figure out which version to use.
- The `julia`-layer is not yet updated to work with the new version of `lsp-mode`, see the link above.

> [@ffevotte](#):
>
> In order to search for something in the documentation, I use [zeal](https://zealdocs.org/) and [zeal-at-point](https://github.com/jinzhu/zeal-at-point). But I don’t like spawning an external process (and window), especially when most of this documentation (and more) is available from Julia itself in a form that could easily be browsed within Emacs (but I haven’t found any readily-available tool to do this).

With `julia-repl` you can just do `C-c C-d` (or `K` in `spacemacs`) on a symbol and the repl will print the documentation.

> [@ffevotte](#):
>
> On another note, one thing I lack is the ability to quickly run tests.

This would be a nice addition, `ESS` has a shortcut for this. If I am working on a single test, most of the times it is sufficient to run that test(-set) interactively until it works and then run the entire suite just to check.

> [@non-Jedi](#):
>
> maybe even publish to Melpa

+1

---

<div class="post-metadata">

**Author:** ![ffevotte](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ffevotte/32/6587_2.png) [@ffevotte](https://discourse.julialang.org/u/ffevotte)\
**Post date:** [January 9, 2019, 1:42pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/5 "2019-01-09T13:42:38Z")

</div>

> [@gdkrmr](#):
>
> With `julia-repl` you can just do `C-c C-d` (or `K` in `spacemacs` ) on a symbol and the repl will print the documentation.

Thanks, I’ll try this.

  

> [@gdkrmr](#):
>
> This would be a nice addition, `ESS` has a shortcut for this

I’ve never used ESS; I’ll have to look at what it does exactly. But would you find it useful if I submitted a PR to `julia-repl`, so that a user-specified command could be sent to the REPL in one key press?

---

<div class="post-metadata">

**Author:** ![gdkrmr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gdkrmr/32/2791_2.png) [@gdkrmr](https://discourse.julialang.org/u/gdkrmr)\
**Post date:** [January 9, 2019, 2:24pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/6 "2019-01-09T14:24:12Z")

</div>

> [@ffevotte](#):
>
> I’ve never used ESS; I’ll have to look at what it does exactly. But would you find it useful if I submitted a PR to `julia-repl` , so that a user-specified command could be sent to the REPL in one key press?

`julia-repl` is probably the best place for this. I would ask @Tamas_Papp about this.

You would probably do something like [here](https://github.com/tpapp/julia-repl/blob/master/julia-repl.el#L527) to locate the project folder.

---

<div class="post-metadata">

**Author:** ![mauro3](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mauro3/32/292_2.png) [@mauro3](https://discourse.julialang.org/u/mauro3)\
**Post date:** [January 9, 2019, 5:04pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/7 "2019-01-09T17:04:53Z")

</div>

> [@ffevotte](#):
>
> In order to search for and (jump to) function definitions, I’m using [InteractiveCodeSearch.jl](https://github.com/tkf/InteractiveCodeSearch.jl). Again, I’d like to streamline the process of looking for the definition of the function at point (which I don’t think would be too difficult; I might try to develop a package to do it if I get around to it…)

I use ctags/etags for this. Works pretty well.

---

<div class="post-metadata">

**Author:** ![ninjaaron](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ninjaaron/32/6392_2.png) [@ninjaaron](https://discourse.julialang.org/u/ninjaaron)\
**Post date:** [January 9, 2019, 5:52pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/8 "2019-01-09T17:52:17Z")

</div>

I just use emacs with julia-mode and some terminals for REPL and running test scripts. I like this zeal thing, though. That’s great!

---

<div class="post-metadata">

**Author:** ![ffevotte](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ffevotte/32/6587_2.png) [@ffevotte](https://discourse.julialang.org/u/ffevotte)\
**Post date:** [January 9, 2019, 9:26pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/9 "2019-01-09T21:26:49Z")

</div>

> [@mauro3](#):
>
> I use ctags/etags for this. Works pretty well.

Thanks, I did not know one could index julia files using ctags. I wonder if you index only Julia itself (and maybe the installed packages), or also your own code (in order to navigate within your sources as you’re developing them). In the latter case, do you have any way to automatically update the index as your sources evolve?

---

<div class="post-metadata">

**Author:** ![mauro3](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mauro3/32/292_2.png) [@mauro3](https://discourse.julialang.org/u/mauro3)\
**Post date:** [January 10, 2019, 11:02am UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/10 "2019-01-10T11:02:10Z")

</div>

I only have it setup for Julia 0.6 at the moment. In .emacs I have:

```julia
;; CTAGS ETAGS
; https://www.emacswiki.org/emacs/EtagsTable
(require 'etags-table)
(setq etags-table-alist
      '(
        (".*\\.jl$" "~/julia/julia-0.6/TAGS" "~/.julia/v0.6/TAGS")
        ))
(setq tags-case-fold-search nil) ; case sensitive search

```

then I bulild the tags with:

```julia
~ >> cat julia/julia-0.6/build-ctags.sh 
#!/bin/sh
ctags -R -e --options=contrib/ctags --languages=julia --totals=yes base
~ >> cat .julia/v0.6/build-ctags.sh  
#!/bin/sh
ctags -R -e --options=/home/mauro/julia/julia-0.6/contrib/ctags --totals=yes --exclude=.* --exclude=.git --languages=julia

```

.i.e. I build a ctags file for julia-base and the installed packages (which also include (most of) my personal package/code).

Navigation is pretty nice with M-. jumping to a function def and M-, back. If there are several methods, they will show in a window to select (which is ok for a few methods but not so useful when there are 10+)

For Julia 1.0, the `julia-0.6/contrib/ctags` file has been moved to [GitHub - JuliaEditorSupport/julia-ctags: Julia language support for CTAGS](https://github.com/JuliaEditorSupport/julia-ctags).

---

<div class="post-metadata">

**Author:** ![Tamas\_Papp](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tamas_papp/32/25949_2.png) [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)\
**Post date:** [January 10, 2019, 1:04pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/11 "2019-01-10T13:04:26Z")

</div>

`julia-repl` is a quick & dirty effort to take advantage of ansi terminal features in Julia. I hope that code introspection (docstrings, function argument lookup) will improve as LanguageServer interfaces stabilize, which is why I am not making a huge effort to develop a parallel solution, as that would imply a fundamental redesign. In the meantime, `C-c C-d` is a stopgap (in particular, it won’t use module names, eg `Foo.bar` will look up `Main.bar`, that is a bug).

For quickly running something without interrupting your main work, consider using a buffer suffix (`C-c C-s`). This will send code to another `*julia-suffix*` buffer. You can use different versions, too (`C-c C-v`).

I look at LanguageServer from time to time, but found it not ready the last time I did that (about 3 months ago). If someone things it is ready for regular use and there is anything I can do on the `julia-repl` side to make it easier, please let me know. I know some open issues have been around for a long time, but I always try to fix them if I get a break from other things.

---

<div class="post-metadata">

**Author:** ![bodie](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/bodie/32/6869_2.png) [@bodie](https://discourse.julialang.org/u/bodie)\
**Post date:** [January 24, 2019, 4:22pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/12 "2019-01-24T16:22:31Z")

</div>

Similar setup here, macOS. I’ve opened [An Issue](https://github.com/JuliaEditorSupport/LanguageServer.jl/issues/328) against `LanguageServer.jl` since it doesn’t want to pass tests to satisfy PackageCompiler.

---

<div class="post-metadata">

**Author:** ![ffevotte](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ffevotte/32/6587_2.png) [@ffevotte](https://discourse.julialang.org/u/ffevotte)\
**Post date:** [January 25, 2019, 9:45pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/13 "2019-01-25T21:45:36Z")

</div>

I thought I would post a small update, since I managed to make `lsp-mode`, `lsp-ui` and [`lsp-julia`](https://github.com/non-Jedi/lsp-julia) work nicely.

Here is the relevant part of my configuration (based on `use-package`), in case someone would be interested:

```nohighlight
(use-package dash)
(use-package s)

```

```nohighlight
(use-package lsp-mode
  :init
  ;; Use flycheck instead of flymake (better lsp-ui integration)
  (setq lsp-prefer-flymake nil)

  :config
  ;; Prevent long documentation showing up in the echo area from messing up the
  ;; window configuration -> only show the first line
  (defun ff/lsp-eldoc-advice (orig-fun &rest args)
    (let ((msg (car args)))
      (if msg
          (funcall orig-fun (->> msg (s-trim-left)
                                     (s-split "\n")
                                     (first))))))
  (advice-add 'lsp--eldoc-message :around #'ff/lsp-eldoc-advice)

  ;; Avoid questions about restarting the LSP server when quitting emacs
  (defun ff/lsp-disable-server-autorestart ()
    (setq lsp-restart nil))
  (add-hook 'kill-emacs-hook #'ff/lsp-disable-server-autorestart))

```

```nohighlight
(use-package lsp-ui
  :ensure t

  :init
  (setq lsp-ui-doc-enable nil)

  :config
  (define-key lsp-ui-mode-map [remap xref-find-definitions] #'lsp-ui-peek-find-definitions)
  (define-key lsp-ui-mode-map [remap xref-find-references] #'lsp-ui-peek-find-references))

```

```nohighlight
;; I've installed lsp-julia as a git submodule of my emacs configuration directory
(use-package lsp-julia
  :load-path (lambda () (expand-file-name "~/.emacs.d/packages/lsp-julia")))

```

---

<div class="post-metadata">

**Author:** ![Tamas\_Papp](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tamas_papp/32/25949_2.png) [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)\
**Post date:** [January 26, 2019, 4:51pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/14 "2019-01-26T16:51:54Z")

</div>

Thanks for the writeup. Sorry for the silly question, but what does it _do_ when it works? Eg how can I show some documentation for a function, or something similar?

---

<div class="post-metadata">

**Author:** ![ffevotte](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ffevotte/32/6587_2.png) [@ffevotte](https://discourse.julialang.org/u/ffevotte)\
**Post date:** [January 26, 2019, 8:37pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/15 "2019-01-26T20:37:03Z")

</div>

Not a silly question, I wondered this myself for a long time before I got LSP to work…

Here is a screenshot:

 ![lsp-julia](https://global.discourse-cdn.com/julialang/original/3X/5/1/51afde869d8dc1066804f15afcc083424e1f33ba.png)

Notice in particular:

- in the modeline:

- in the echo area:

- in the “Foo.jl” buffer

- a few actions that LSP allows you to perform:

This is more or less everything that I discovered (by reading/skimming the docs and experimenting a bit). There might be other stuff.

---

<div class="post-metadata">

**Author:** ![chase](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chase/32/7146_2.png) [@chase](https://discourse.julialang.org/u/chase)\
**Post date:** [February 19, 2019, 5:38pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/16 "2019-02-19T17:38:57Z")

</div>

@ffevotte’s configuration works well for me, _if I am in a package_, but not otherwise.

For instance, I have been working with [Gen.jl](https://github.com/probcomp/Gen) recently, and the configuration works great for navigating and working with the package’s files in the `/src/` directory. However, say I switch over to `/examples/` to try and run the examples related to the package, I exclusively get the errors on undeclared variables, so the lines

```julia
import Distributions
import Gen: random, logpdf

```

gives the errors `Julia language server: Use of possibly undeclared variable: <X> [Missing variable]`, where `X` is `[Distributions, Gen, random, logpdf]`. This is related to the `LanguageServer.jl`, but I’m not familiar enough with `lsp` to know where I’m going wrong here.

Any pointers or suggestions?

---

<div class="post-metadata">

**Author:** ![gdkrmr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gdkrmr/32/2791_2.png) [@gdkrmr](https://discourse.julialang.org/u/gdkrmr)\
**Post date:** [February 28, 2019, 12:50pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/17 "2019-02-28T12:50:45Z")

</div>

`LanguageServer.jl` does not work when you are not inside a package. E.g. I have a file `~/test.jl` which I use for quick testing and `LanguageServer.jl` starts searching my entire home folder. Blacklisting `~` is no good, because it blacklists all sub-folders.

---

<div class="post-metadata">

**Author:** ![Elrod](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/elrod/32/22461_2.png) [@Elrod](https://discourse.julialang.org/u/Elrod)\
**Post date:** [June 8, 2019, 2:27pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/18 "2019-06-08T14:27:38Z")

</div>

EDIT:  
LSP Julia doesn’t work for me, but I can get autocompletions with:

```nohighlight
(add-to-list 'company-backends `(company-dabbrev))
(setq company-dabbrev-downcase nil)

```

---

<div class="post-metadata">

**Author:** ![gdkrmr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gdkrmr/32/2791_2.png) [@gdkrmr](https://discourse.julialang.org/u/gdkrmr)\
**Post date:** [June 9, 2019, 10:14pm UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/19 "2019-06-09T22:14:12Z")

</div>

Have you tried updating `lsp-mode`? There was an issue which should be fixed by [https://github.com/emacs-lsp/lsp-mode/pull/827](https://github.com/emacs-lsp/lsp-mode/pull/827).

---

<div class="post-metadata">

**Author:** ![Elrod](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/elrod/32/22461_2.png) [@Elrod](https://discourse.julialang.org/u/Elrod)\
**Post date:** [June 10, 2019, 5:00am UTC](https://discourse.julialang.org/t/emacs-based-workflow/19400/20 "2019-06-10T05:00:05Z")

</div>

Ah. I believe I’m using [melpa-stable’s lsp-mode](https://stable.melpa.org/#/lsp-mode), which is on [commit 789b67](https://github.com/emacs-lsp/lsp-mode/commit/789b672500dcbb2350bb5b667ffc0fd037a8b2e3) (the latest release), which dates to January of this year.

I’ll try switching to regular melpa.

EDIT:  
Also, I finally decided to commit to switching to Emacs about a month ago, so I’m still fairly new.  
I confess I don’t know elisp.

[Next page](https://discourse.julialang.org/t/emacs-based-workflow/19400.md?page=2)