Tips for the Julia `startup.jl</code> file`


Martin Kunz — Fri, 05 Sep 2025 00:00:00 +0000
I have lately spent some time switching between an editor, paper and the Julia REPL, which made me realize how much more
pleasant I have made this workflow for myself by stuff I have in the startup file.</p>

What is the startup.jl</code> file?!</strong>

For those who are not accustomed with the concept of the startup file in Julia, briefly, it is a script that is run once
you enter the REPL.
It is stored at $JULIA_DEPOT_PATH/config/startup.jl</code> or if the JULIA_DEPOT_PATH</code> environment variable is not set, the
default on GNU/UNIX</em> is $HOME/.julia/</code>.
Here you can find more about the
startup.jl</code></a> file.</p>
</blockquote>
Some of the changes that I made may be useful to you as well!</p>
Loading Packages for Interactive Use Only</h1>
Most people use it for loading packages that they use often enough that they value of having the package functionality
available at startup is higher than the price of the REPL startuptime.
The library packages that meet this criterium for me are
BenchmarkTools</code></a> and Makie</code></a>.
It is always a good idea when loading packages for interactive use to include them conditionally only when the session
is interactive</em> with</p>
try</span></span>
    if</span> isinteractive</span>(</span>)</span></span>
        using</span> Makie</span></span>
    end</span></span>
catch</span> e</span></span>
    @warn</span> "</span>Error initializing Makie</span>"</span> exception </span>=</span> (</span>e</span>,</span> catch_backtrace</span>(</span>)</span>)</span></span>
end</span></span></code></pre>

The try/catch</code> control sequence is here, since I switch between different versions of Julia and I do not always make
sure that everything is installed.</p>
</blockquote>
This way you are only paying the expense when you actually need it and not when running scripts or generating
documentation for example.</p>
Other Useful Packages</h1>
Non-library packages that may improve your experience with the Julia REPL when using it interactively which I also are
important to me are these…</p>

Revise</code></a></dt>
It has become more of a must have in the community and is also recommended by the official Julia documentation. It
manges the changes that you make in your loaded packages and allows the REPL environment to reflect changes that you
make in real time.</dd>
OhMyRepl</code></a></dt>
Features include syntax highlighting in your REPL, markdown syntax for documentation and fuzzy searching with
fzf</code></a> of the REPL history.</dd>
VimBindings</code></a></dt>
Enables editing the command line with modal Vim bindings.</dd>
</dl>
Additional Functions</h1>
It is also useful to define some functions that you can use for exploration and debugging purposes.
For example, I have a subtypetree</code> function which allows me to see all of the subtypes of a particular abstract type to
decide on what interfaces I should use for my own implementations.</p>
julia></span> subtypetree</span>(</span>Integer</span>)</span></span>
Integer</span></span>
  Bool</span></span>
  GeometryBasics</span>.</span>OffsetInteger</span></span>
  Signed</span></span>
    BigInt</span></span>
    Int128</span></span>
    Int16</span></span>
    Int32</span></span>
    Int64</span></span>
    Int8</span></span>
  Unsigned</span></span>
    UInt128</span></span>
    UInt16</span></span>
    UInt32</span></span>
    UInt64</span></span>
    UInt8</span></span></code></pre>
Definition of subtypetree</code></summary>
function</span> subtypetree</span>(</span>roottype</span>,</span> level</span>=</span>1</span>,</span> indent</span>=</span>2</span>)</span></span>
    level </span>==</span> 1</span> &&</span> println</span>(</span>roottype</span>)</span></span>
    for</span> s </span>in</span> subtypes</span>(</span>roottype</span>)</span></span>
        println</span>(</span>join</span>(</span>fill</span>(</span>"</span> "</span>,</span> level </span>*</span> indent</span>)</span>)</span> *</span> string</span>(</span>s</span>)</span>)</span></span>
        subtypetree</span>(</span>s</span>,</span> level </span>+</span> 1</span>,</span> indent</span>)</span></span>
    end</span></span>
end</span></span></code></pre>
</details>
Change the Pages for @less</code></h1>

What is this @less</code> that you are talking about?</strong>

If you do not use @less</code> and @edit</code>, you should definitely check them out!
These are tools that allow you to inspect the source code of functions implemented in some package (or defined earlier
within the REPL).
Usually when I have the editor and the REPL open and any of my calls to library functions have unexpected outputs,
I would like to inspect what is happening in its implementation.
You could surely use GoToImplemention</code> from the language server if you are within the editor context, but I find
@less</code> and @edit</code> to be useful in the REPL as well.
Most importantly, I use this when I want to look up how some function is implemented in the Julia Base</code> or in some
external package, because I want to implement something similar myself.</p>
</blockquote>
Also you might want to integrate some tools that you use on your system and use them instead of the defaults.
One nice enhancement that I have in this category is using bat</code> instead of less</code> as the pager for in the
InteractiveUtils.less</code> function.
You can achieve this by including the code</p>
try</span></span>
    if</span> isinteractive</span>(</span>)</span></span>
        using</span> InteractiveUtils</span></span>
        function</span> InteractiveUtils</span>.</span>less</span>(</span>file</span>::</span>AbstractString</span>,</span> line</span>::</span>Integer</span>)</span></span>
            run</span>(</span>`</span>bat --paging=always --line-range </span>$</span>(</span>line</span>)</span>: </span>$file</span>`</span>)</span></span>
            nothing</span></span>
        end</span></span>
    end</span></span>
catch</span> e</span></span>
    @warn</span> "</span>Error initializing InteractiveUtils</span>"</span> exception </span>=</span> (</span>e</span>,</span> catch_backtrace</span>(</span>)</span>)</span></span>
end</span></span></code></pre>
in your startup.jl</code> file.
This allows me to switch context between reading code that is run and running the code while staying in the REPL using
@less</code> instead of @edit</code> which opens the code in the terminal.
It gives you syntax highlighting of the output Julia source of the function that you are inspecting.</p>
Imagine that you want to see how the split</code> function is implemented from Base</code>.
Perhaps you want to see if there is an iterator with the same behaviour and suspect that it would be present in the
implementation.
For this reason, you call</p>
julia></span> @less</span> split</span>(</span>"</span>a,b</span>"</span>,</span> "</span>,</span>"</span>)</span></span></code></pre>
From the default InteractiveUtils.less</code> definition that uses the less</code> (or the $PAGER</code> environment variable) command
to page the output you can expect something similar to this:</p>
function split(str::T, splitter;</span></span>
               limit::Integer=0, keepempty::Bool=true) where {T<:AbstractString}</span></span>
    collect(eachsplit(str, splitter; limit, keepempty))</span></span>
end</span></span>
</span>
# a bit oddball, but standard behavior in Perl, Ruby & Python:</span></span></code>
</pre>
It has the correct output but it is not very pleasant to read.
You can imagine that you are analysing the implementation of a larger function… This would be quite a pain.</p>
If you change the InterativeUtils.less</code> function definition to use bat</code></a> as described
above, you can expect something like this:</p>
File: /home/kunzaatko/.julia/juliaup/julia-1.12.3+0.x64.linux.gnu/share/julia/base/strings/util.jl</b>
function</span> </span>split</span>(</span>str</span>::</span>T</span>,</span> splitter</span>;</span>
               limit</span>::</span>Integer</span>=</span>0</span>,</span> keepempty</span>::</span>Bool</span>=</span>true</span>)</span> </span>where</span> </span>{</span>T</span><:</span>AbstractString</span>}</span>
    collect</span>(</span>eachsplit</span>(</span>str, splitter; limit, keepempty</span>))</span>
end</span>

# a bit oddball, but standard behavior in Perl, Ruby & Python:</span>
</code>
</pre>
which is way nicer to read…</p>
I hope you enjoyed this non-exhaustive view into the contents of my startup.jl</code> and that you perhaps found something
useful for your own that could make the beautiful experience of writing Julia code a little less frustrating…</p>
Random Sampler

Tips for the Julia startup.jl</code> file

Tips for the Julia `startup.jl</code> file`
