JULIA(1)              Julia Programmers' Reference Guide              JULIA(1)

NAME
       julia - high-level, high-performance dynamic programming language for
       technical computing

SYNOPSIS
       julia [option] [program] [args..]

DESCRIPTION
       Julia is a high-level, high-performance dynamic programming language
       for technical computing, with syntax that is familiar to users of other
       technical computing environments.  It provides a sophisticated
       compiler, distributed parallel execution, numerical accuracy, and an
       extensive mathematical function library.  The library, largely written
       in Julia itself, also integrates mature, best-of-breed C and Fortran
       libraries for linear algebra, random number generation, signal
       processing, and string processing.  In addition, the Julia developer
       community is contributing a number of external packages through Julia's
       built-in package manager at a rapid pace.  Julia programs are organized
       around multiple dispatch; by defining functions and overloading them
       for different combinations of argument types, which can also be user-
       defined.  For a more in-depth discussion of the rationale and
       advantages of Julia over other systems, please see the online manual:
       https://docs.julialang.org

       If a Julia source file is given as a program (optionally followed by
        arguments in args) Julia will execute the program and exit.

COMMAND-LINE OPTIONS
       -v, --version
              Display version information

       -h, --help
              Print help message

       --project[=<dir>/@.]
              Set <dir> as the home project/environment. The default @. option
              will search through parent directories until a Project.toml or
              JuliaProject.toml file is found.

       -J, --sysimage <file>
              Start up with the given system image file

       --sysimage-native-code={yes|no}
              Use precompiled code from system image if available

       -H, --home <dir>
              Set location of julia executable

       --startup-file={yes|no}
              Load ~/.julia/config/startup.jl

       --handle-signals={yes|no}
              Enable or disable Julia's default signal handlers

       -e, --eval <expr>
              Evaluate <expr>

       -E, --print <expr>
              Evaluate <expr> and display the result

       -L, --load <file>
              Load <file> immediately on all processors

       -t, --threads <n>
              Enable n threads

       -p, --procs <n>
              Run n local processes

       --machine-file <file>
              Run processes on hosts listed in <file>

       -i     Interactive mode; REPL runs and isinteractive() is true

       --banner={yes|no|auto}
              Enable or disable startup banner

       --color={yes|no|auto}
              Enable or disable color text

       --history-file={yes|no}
              Load or save history

       --compile={yes|no|all|min}
              Enable or disable compiler, or request exhaustive or minimal
              compilation

       -C, --cpu-target=<target>
              Limit usage of cpu features up to <target>

       -O, --optimize
              Run time-intensive code optimizations

       -O <n>, --optimize=<n>
              Set the optimization level to <n>

       -g     Enable generation of full debug info

       -g <n> Set the level of debug info generation to <n>

       --inline={yes|no}
              Control whether inlining is permitted (overrides functions
              declared as @inline)

       --check-bounds={yes|no}
              Emit bounds checks always or never (ignoring declarations)

       --math-mode={ieee|user}
              Always use IEEE semantics for math (ignoring declarations), or
              adhere to declarations in source code

       --depwarn={yes|no|error}
              Enable or disable syntax and method deprecation warnings
              ('error' turns warnings into errors)

       --warn-overwrite={yes|no}
              Enable or disable method overwrite warnings

       --output-o <name>
              Generate an object file (including system image data)

       --output-ji <name>
              Generate a system image data file (.ji)

       --output-bc <name>
              Generate LLVM bitcode (.bc)

       --output-incremental={yes|no}
              Generate an incremental output file (rather than complete)

       --code-coverage={none|user|all}, --code-coverage
              Count executions of source lines (omitting setting is equivalent
              to 'user')

       --track-allocation={none|user|all}, --track-allocation
              Count bytes allocated by each source line

FILES
       ~/.julia/config/startup.jl
              Per user startup file.

       /etc/julia/startup.jl
              System-wide startup file.

BUGS
       Please report any bugs using the GitHub issue tracker:
       https://github.com/julialang/julia/issues?state=open

AUTHORS
       Contributors: https://github.com/JuliaLang/julia/graphs/contributors

Julia                             2013-12-10                          JULIA(1)