Send code to Julia REPL?

[DimitarVanguelov]

I apologize if this is covered somewhere already (I couldn't find it) -- is there a way to send Julia code to its REPL (similar to vim slime)? I normally use VS Code, but am curious about command line editors and Helix looks amazing. Setting it up with Julia LSP was a breeze, and I had syntax highlighting and intellisense within minutes. However, the icing, so to speak, would be having an interactive, notebook like support since that is how Julia is often used. Something like having Helix on one side of a Zellij window and Julia REPL on the other.

Thanks in advance and kudos on this project!

[Robert-j7]

I am eagerly looking for a solution like this, I don't think there is a built in command yet for this, have you found a work around for this ?

[kirawi]

I believe this would require a plugin.

[benjaminrich]

The "killer" feature would be to have a built-in REPL for any interactive language. For working with interactive languages (e.g. R, julia) the ability to "send code to REPL" is essential.

In vim, you have e.g. the nvim-r plugin which is fantastic for R, but doesn't help at all with julia, for example. The ideal solution for helix would:

• have consistent key bindings across languages
• not require any plugins (this is the strength of helix)
• not rely on external tools like tmux

One of the amazingly useful features that nvim-r has is \o: evaluate and insert the output as comment. I can't tell you how useful this is; I wish I could get the same functionality with julia.

I have no idea how this would be implemented, unfortunately; it may require an integrated terminal (#1976), I don't know. But if you want be be able to use helix as an editor for a language like R, you need something like this.

[zetashift]

Related plugins, maybe for inspiration:
https://github.com/michaelb/sniprun
https://github.com/hkupty/iron.nvim

I do think this feature request should be implemented as a plugin.

[dbdahl]

I too would love the ability to send code to an REPL (in my case, usually R or my shell). This is the key feature that is keeping me from moving from nvim to helix. Integrating a terminal in helix might be heavy lift, but it seems that an integration in zellij or tmux might be much simpler.

[RobinJadoul]

I wrote something quick for myself to use. It doesn't have a built-in terminal for helix, it relies on tmux instead.
On the upside, since it's using jupyter, it should be easy to make it work for julia (with https://github.com/JuliaLang/IJulia.jl) or R (with https://irkernel.github.io/) or anything else that has a jupyter kernel.

See https://gist.github.com/RobinJadoul/aab9ea148dbd2a81cc1e896120638cf1 for what I did

[nilsmartel]

This sounds a lot like vim-slime https://github.com/jpalardy/vim-slime

This plugin is super useful:
Using the plugin you can insert anything you have in your buffer to literally any other terminal window.

It doesn't matter what it's running, making it super versatile

[KronosTheLate]

+1 that this would be super useful

[peter-fm]

Yes I use this all the time with python and R in vs code. Would love this in helix.

[feribg]

this is a very viable solution i think which can be added directly in helix, given that it's a rust library to send / receive data from interactive shell scripts https://github.com/andyk/ht I think even a macro can be hacked to do send selection to something.py that calls ht and starts a julia repl with the current path as active project or executes in an already running repl

[KronosTheLate]

It should definitively be sendt to an already running REPL given Julia's startup times. But a command that opens a new REPL might be very nice for establishing the connection between editor and REPL - I recall finding that step difficult when attempting to set up TMUX

[feribg]

Yep starting the REPL and all that is trivial, i guess the problem is how to talk with it and there's a few ways to accomplish that:

• https://stackoverflow.com/questions/53323489/julia-invoke-script-on-existing-repl-from-command-line
• https://github.com/julia-vscode/julia-vscode/blob/main/scripts/terminalserver/load_vscodeserver.jl using distributed and a server to run the code
• something like what i suggested above which i personally like the most, essentially a way for the editor to interact with any terminal interactively, which is a good stepping stone to supporting any other REPL down the line without having to write custom servers / sockets / whathaveyou and is reasonably self contained.

[nilsmartel]

I can only really emphasis to check out slime.nvim.

It feels like a very simple solution to the problem with rather broad applications

[ernesxavier]

The Intellisense does not work for me, as configured. I tried NVIM, but the setup becomes overwhelming, in that sense HELIX is amazing. It would be nice if we could use the REPL like in VSCODE.

[mauro3]

Note that there are quite a few work-arounds posted in issue #2806, for example #2806 (comment) .

[mauro3]

I wrote up my setup to send code from Helix to the REPL: https://maurow.bitbucket.io/notes/helix-julia-latex-setup.html

[milanglacier]

I create a github repo for my workflow integration for Helix editor, Zellij, AI CLI apps, and REPL environments built around two minimal scripts with nearly zero dependencies. Video showcases are included in README for demonstration.

https://github.com/milanglacier/Helix-Zellij-AI-REPL-Workflow

[a-berg]

there's this blogpost I have used to set up TidalCycles for live coding: https://int8.tech/posts/repl-programming-helix-zellij-devenv/

[gabdst]

Here is a tmux setup for sending code to a Julia REPL

[keys.select.space.e]
e = ":pipe-to tmux load-buffer -b repl - \\; paste-buffer -b repl -t ':2'"
n = ":sh tmux new-window -dS -a -n 'repl' zsh \\; move-window -ad -s ':=repl' -t ':1'"
k = ":sh tmux kill-window -t :repl \\; move-window -r"
j = ":sh tmux new-window -dS -a -n 'repljulia' julia --project=@. \\; move-window -ad -s ':=repljulia' -t ':1'"
p = ":sh tmux new-window -dS -a -n 'replpython' ipython3 --no-autoindent \\; move-window -ad -s ':=replpython' -t ':1'"

[keys.normal.space.e]
e = ":pipe-to tmux load-buffer -b repl - \\; paste-buffer -b repl -t ':2'"
n = ":sh tmux new-window -dS -a -n 'repl' zsh \\; move-window -ad -s ':=repl' -t ':1'"
k = ":sh tmux kill-window -t :repl \\; move-window -r"
j = ":sh tmux new-window -dS -a -n 'repljulia' julia --project=@. \\; move-window -ad -s ':=repljulia' -t ':1'"
p = ":sh tmux new-window -dS -a -n 'replpython' ipython3 --no-autoindent \\; move-window -ad -s ':=replpython' -t ':1'"

I am using windows instead of panes with a tmux keybinding (ALT+#window_number) that allows to go back and forth between the helix window and the julia REPL (and other repls, here bash and python). It works in normal and selection mode. This setup assumes that the REPL is the second window. Only one REPL session -of your favorite language (bash, python, julia here)- is allowed and calling another one will just reposition the REPL next to the editor window.

[sinnerbichler]

I would like to contribute my own solution: it uses zellij and zjctl (and nushell).
depending on the language of the active buffer, Ctrl+M opens a pane with the correct repl, and Ctrl+Space sends text under the selection there.

[keys.normal]
# create new pane with name "repl"
# depending on language it launches the respective repl:
# python: ipython --quiet --no-autoindent --pprint --color-info --matplotlib --no-banner --no-confirm-exit --no-tip --quick 
# julia: julia
# R: R --quiet --no-save
# if the opened file (active buffer) is the scratch buffer or the language isn't one of the above, it should run the command bash
C-m = [
  ":sh zellij run -c -n repl -- %sh{nu -c 'match \"%{language}\" { \"python\" => \"ipython --quiet --no-autoindent --pprint --color-info --matplotlib --no-banner --no-confirm-exit --no-tip --quick\", \"julia\" => \"julia\", \"r\" => \"R --quiet --no-save\", _ => \"nu\" }'} > /dev/null"
]

# send selected text to the pane named "repl"
C-space = [
  ":pipe-to zjctl pane send --enter=true --delay-enter=0.0 --pane 'title:repl' -- \"$(cat)\""
]