Command-line Interface

Using arguments inside scripts

When running a script using julia, you can pass additional arguments to your script:

$ julia script.jl arg1 arg2...

These additional command-line arguments are passed in the global constant ARGS. The name of the script itself is passed in as the global PROGRAM_FILE. Note that ARGS is also set when a Julia expression is given using the -e option on the command line (see the julia help output below) but PROGRAM_FILE will be empty. For example, to just print the arguments given to a script, you could do this:

$ julia -e 'println(PROGRAM_FILE); for x in ARGS; println(x); end' foo bar

foo
bar

Or you could put that code into a script and run it:

$ echo 'println(PROGRAM_FILE); for x in ARGS; println(x); end' > script.jl
$ julia script.jl foo bar
script.jl
foo
bar

The -- delimiter can be used to separate command-line arguments intended for the script file from arguments intended for Julia:

$ julia --color=yes -O -- script.jl arg1 arg2..

See also Scripting for more information on writing Julia scripts.

The Main.main entry point

As of Julia, 1.11, Base exports the macro @main. This macro expands to the symbol main, but at the conclusion of executing a script or expression, julia will attempt to execute Main.main(Base.ARGS) if such a function Main.main has been defined and this behavior was opted into by using the @main macro.

This feature is intended to aid in the unification of compiled and interactive workflows. In compiled workflows, loading the code that defines the main function may be spatially and temporally separated from the invocation. However, for interactive workflows, the behavior is equivalent to explicitly calling exit(main(ARGS)) at the end of the evaluated script or expression.

To see this feature in action, consider the following definition, which will execute the print function despite there being no explicit call to main:

$ julia -e '(@main)(args) = println("Hello World!")'
Hello World!
$

Only the main binding in the Main module has this behavior and only if the macro @main was used within the defining module.

For example, using hello instead of main will not result in the hello function executing:

$ julia -e 'hello(args) = println("Hello World!")'
$

and neither will a plain definition of main:

$ julia -e 'main(args) = println("Hello World!")'
$

However, the opt-in need not occur at definition time:

$ julia -e 'main(args) = println("Hello World!"); @main'
Hello World!
$

The main binding may be imported from a package. A hello world package defined as

module Hello

export main
(@main)(args) = println("Hello from the package!")

end

may be used as:

$ julia -e 'using Hello'
Hello from the package!
$ julia -e 'import Hello' # N.B.: Execution depends on the binding not whether the package is loaded
$

However, note that the current best practice recommendation is to not mix application and reusable library code in the same package. Helper applications may be distributed as separate packages or as scripts with separate main entry points in a package's bin folder.

Parallel mode

Julia can be started in parallel mode with either the -p or the --machine-file options. -p n will launch an additional n worker processes, while --machine-file file will launch a worker for each line in file file. The machines defined in file must be accessible via a password-less ssh login, with Julia installed at the same location as the current host. Each machine definition takes the form [count*][user@]host[:port] [bind_addr[:port]]. user defaults to current user, port to the standard ssh port. count is the number of workers to spawn on the node, and defaults to 1. The optional bind-to bind_addr[:port] specifies the IP address and port that other workers should use to connect to this worker.

Startup file

If you have code that you want executed whenever Julia is run, you can put it in ~/.julia/config/startup.jl:

$ echo 'println("Greetings! 你好! 안녕하세요?")' > ~/.julia/config/startup.jl
$ julia
Greetings! 你好! 안녕하세요?

...

Note that although you should have a ~/.julia directory once you've run Julia for the first time, you may need to create the ~/.julia/config folder and the ~/.julia/config/startup.jl file if you use it.

To have startup code run only in The Julia REPL (and not when julia is e.g. run on a script), use atreplinit in startup.jl:

atreplinit() do repl
    # ...
end

Command-line switches for Julia

There are various ways to run Julia code and provide options, similar to those available for the perl and ruby programs:

julia [switches] -- [programfile] [args...]

The following is a complete list of command-line switches available when launching julia (a '*' marks the default value, if applicable; settings marked '($)' may trigger package precompilation):

Options that have the form --option={...} can be specified either as --option=value or as --option value. For example, julia --banner=no is equivalent to julia --banner no. This is especially relevant for options that take a filename for output, because forgetting to specifying the argument for (say) --trace-compile will cause the option following it to be interpreted as the filename, possibly unintentionally overwriting it.

Note that options of the form --option[=...] can not be specified as --option value, but only as --option=value (or simply --option, when no argument is provided).