Julia may be configured with a number of environment variables, either in the
usual way of the operating system, or in a portable way from within Julia.
Suppose you want to set the environment variable JULIA_EDITOR
to
vim
, then either type ENV["JULIA_EDITOR"] = "vim"
for instance in the REPL
to make this change on a case by case basis, or add the same to the user
configuration file ~/.julia/config/startup.jl
in the user's home directory to have
a permanent effect. The current value of the same environment variable is
determined by evaluating ENV["JULIA_EDITOR"]
.
The environment variables that Julia uses generally start with JULIA
. If
InteractiveUtils.versioninfo
is called with verbose
equal to true
, then the
output will list defined environment variables relevant for Julia, including
those for which JULIA
appears in the name.
The absolute path of the directory containing the Julia executable, which sets
the global variable Sys.BINDIR
. If $JULIA_BINDIR
is not set, then
Julia determines the value Sys.BINDIR
at run-time.
The executable itself is one of
$JULIA_BINDIR/julia
$JULIA_BINDIR/julia-debug
by default.
The global variable Base.DATAROOTDIR
determines a relative path from
Sys.BINDIR
to the data directory associated with Julia. Then the path
$JULIA_BINDIR/$DATAROOTDIR/julia/base
determines the directory in which Julia initially searches for source files (via
Base.find_source_file()
).
Likewise, the global variable Base.SYSCONFDIR
determines a relative path to the
configuration file directory. Then Julia searches for a startup.jl
file at
$JULIA_BINDIR/$SYSCONFDIR/julia/startup.jl
$JULIA_BINDIR/../etc/julia/startup.jl
by default (via Base.load_julia_startup()
).
For example, a Linux installation with a Julia executable located at
/bin/julia
, a DATAROOTDIR
of ../share
, and a SYSCONFDIR
of ../etc
will
have JULIA_BINDIR
set to /bin
, a source-file search path of
/share/julia/base
and a global configuration search path of
/etc/julia/startup.jl
A separated list of absolute paths that are to be appended to the variable
LOAD_PATH
. (In Unix-like systems, the path separator is :
; in
Windows systems, the path separator is ;
.) The LOAD_PATH
variable is where
Base.require
and Base.load_in_path()
look for code; it defaults to
the absolute path
$JULIA_HOME/../share/julia/stdlib/v$(VERSION.major).$(VERSION.minor)
so that,
e.g., version 0.7 of Julia on a Linux system with a Julia executable at
/bin/julia
will have a default LOAD_PATH
of /share/julia/stdlib/v0.7
.
The absolute path REPL.find_hist_file()
of the REPL's history file. If
$JULIA_HISTORY
is not set, then REPL.find_hist_file()
defaults to
$HOME/.julia/logs/repl_history.jl
A positive Int
that determines how much time the max-sum subroutine
MaxSum.maxsum()
of the package dependency resolver
will devote to attempting satisfying constraints before giving up: this value is
by default 1
, and larger values correspond to larger amounts of time.
Suppose the value of $JULIA_PKGRESOLVE_ACCURACY
is n
. Then
- the number of pre-decimation iterations is
20*n
, - the number of iterations between decimation steps is
10*n
, and - at decimation steps, at most one in every
20*n
packages is decimated.
The absolute path of the shell with which Julia should execute external commands
(via Base.repl_cmd()
). Defaults to the environment variable $SHELL
, and
falls back to /bin/sh
if $SHELL
is unset.
!!! note
On Windows, this environment variable is ignored, and external commands are
executed directly.
The editor returned by InteractiveUtils.editor()
and used in, e.g., InteractiveUtils.edit
,
referring to the command of the preferred editor, for instance vim
.
$JULIA_EDITOR
takes precedence over $VISUAL
, which in turn takes precedence
over $EDITOR
. If none of these environment variables is set, then the editor
is taken to be open
on Windows and OS X, or /etc/alternatives/editor
if it
exists, or emacs
otherwise.
Overrides the global variable Base.Sys.CPU_THREADS
, the number of
logical CPU cores available.
A Float64
that sets the value of Base.worker_timeout()
(default: 60.0
).
This function gives the number of seconds a worker process will wait for
a master process to establish a connection before dying.
An unsigned 64-bit integer (uint64_t
) that sets the maximum number of threads
available to Julia. If $JULIA_NUM_THREADS
exceeds the number of available
physical CPU cores, then the number of threads is set to the number of cores. If
$JULIA_NUM_THREADS
is not positive or is not set, or if the number of CPU
cores cannot be determined through system calls, then the number of threads is
set to 1
.
If set to a string that starts with the case-insensitive substring "infinite"
,
then spinning threads never sleep. Otherwise, $JULIA_THREAD_SLEEP_THRESHOLD
is
interpreted as an unsigned 64-bit integer (uint64_t
) and gives, in
nanoseconds, the amount of time after which spinning threads should sleep.
If set to anything besides 0
, then Julia's thread policy is consistent with
running on a dedicated machine: the master thread is on proc 0, and threads are
affinitized. Otherwise, Julia lets the operating system handle thread policy.
Environment variables that determine how REPL output should be formatted at the terminal. Generally, these variables should be set to ANSI terminal escape sequences. Julia provides a high-level interface with much of the same functionality: see the section on The Julia REPL.
The formatting Base.error_color()
(default: light red, "\033[91m"
) that
errors should have at the terminal.
The formatting Base.warn_color()
(default: yellow, "\033[93m"
) that warnings
should have at the terminal.
The formatting Base.info_color()
(default: cyan, "\033[36m"
) that info
should have at the terminal.
The formatting Base.input_color()
(default: normal, "\033[0m"
) that input
should have at the terminal.
The formatting Base.answer_color()
(default: normal, "\033[0m"
) that output
should have at the terminal.
The formatting Base.stackframe_lineinfo_color()
(default: bold, "\033[1m"
)
that line info should have during a stack trace at the terminal.
The formatting Base.stackframe_function_color()
(default: bold, "\033[1m"
)
that function calls should have during a stack trace at the terminal.
If set, these environment variables take strings that optionally start with the
character 'r'
, followed by a string interpolation of a colon-separated list of
three signed 64-bit integers (int64_t
). This triple of integers a:b:c
represents the arithmetic sequence a
, a + b
, a + 2*b
, ... c
.
- If it's the
n
th time thatjl_gc_pool_alloc()
has been called, andn
belongs to the arithmetic sequence represented by$JULIA_GC_ALLOC_POOL
, then garbage collection is forced. - If it's the
n
th time thatmaybe_collect()
has been called, andn
belongs to the arithmetic sequence represented by$JULIA_GC_ALLOC_OTHER
, then garbage collection is forced. - If it's the
n
th time thatjl_gc_collect()
has been called, andn
belongs to the arithmetic sequence represented by$JULIA_GC_ALLOC_PRINT
, then counts for the number of calls tojl_gc_pool_alloc()
andmaybe_collect()
are printed.
If the value of the environment variable begins with the character 'r'
, then
the interval between garbage collection events is randomized.
!!! note
These environment variables only have an effect if Julia was compiled with
garbage-collection debugging (that is, if `WITH_GC_DEBUG_ENV` is set to `1`
in the build configuration).
If set to anything besides 0
, then the Julia garbage collector never performs
"quick sweeps" of memory.
!!! note
This environment variable only has an effect if Julia was compiled with
garbage-collection debugging (that is, if `WITH_GC_DEBUG_ENV` is set to `1`
in the build configuration).
If set to anything besides 0
, then the Julia garbage collector will wait for
a debugger to attach instead of aborting whenever there's a critical error.
!!! note
This environment variable only has an effect if Julia was compiled with
garbage-collection debugging (that is, if `WITH_GC_DEBUG_ENV` is set to `1`
in the build configuration).
If set to anything besides 0
, then the compiler will create and register an
event listener for just-in-time (JIT) profiling.
!!! note
This environment variable only has an effect if Julia was compiled with JIT
profiling support, using either
- Intel's VTune™ Amplifier
(
USE_INTEL_JITEVENTS
set to1
in the build configuration), or - OProfile (
USE_OPROFILE_JITEVENTS
set to1
in the build configuration).
Arguments to be passed to the LLVM backend.
If set, then Julia prints detailed information about the cache in the loading
process of Base.require
.