Command-line Interface

Using arguments inside scripts

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

$ julia script.jl arg1 arg2...

These additional command-line arguments are passed in the global constantARGS. The name of the script itself is passed in as the globalPROGRAM_FILE. Note thatARGS is also set when a Julia expression is given using the-e option on the command line (see thejulia help output below) butPROGRAM_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 barfoobar

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 barscript.jlfoobar

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 alsoScripting for more information on writing Julia scripts.

TheMain.main entry point

As of Julia, 1.11,Base exports the macro@main. This macro expands to the symbolmain, but at the conclusion of executing a script or expression,julia will attempt to executeMain.main(Base.ARGS) if such a functionMain.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 themain function may be spatially and temporally separated from the invocation. However, for interactive workflows, the behavior is equivalent to explicitly callingexit(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 tomain:

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

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

For example, usinghello instead ofmain will not result in thehello function executing:

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

and neither will a plain definition ofmain:

$ 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!$

Themain binding may be imported from a package. Ahello world package defined as

module Helloexport 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 separatemain entry points in a package'sbin folder.

Parallel mode

Julia can be started in parallel mode with either the-p or the--machine-file options.-p n will launch an additionaln worker processes, while--machine-file file will launch a worker for each line in filefile. The machines defined infile must be accessible via a password-lessssh 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 optionalbind-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$ juliaGreetings! 你好! 안녕하세요?...

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 inThe Julia REPL (and not whenjulia ise.g. run on a script), useatreplinit instartup.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 theperl andruby 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 tojulia --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[=...] cannot be specified as--option value, but only as--option=value (or simply--option, when no argument is provided).