Join 10350+ others. No spamming.
I promise!

Follow us at github.



JuliaLang / IJulia.jl


Julia kernel for Jupyter

IJulia logo

Build Status Build status


IJulia is a Julia-language backend combined with the Jupyter interactive environment (also used by IPython). This combination allows you to interact with the Julia language using Jupyter/IPython's powerful graphical notebook, which combines code, formatted text, math, and multimedia in a single document.

(IJulia notebooks can also be re-used in other Julia code via the NBInclude package.)


First, download Julia version 0.3 or later and run the installer. Then run the Julia application (double-click on it); a window with a julia> prompt will appear. At the prompt, type:


to install IJulia.

The Pkg.add process will look for a program named jupyter or ipython (version 3 or later) in your PATH. If it doesn't find one, it will use the Conda.jl package to install a minimal Python+Jupyter distribution (via Miniconda) that is private to Julia (not in your PATH). You can use the Conda Julia package to install more Python packages, and import Conda to print the Conda.SCRIPTDIR directory where jupyter was installed.

Alternatively, you can install Jupyter (or IPython 3 or later) yourself before adding the IJulia package. The simplest way to do this on Mac and Windows is by downloading the Anaconda package and running its installer. (Do not use Enthought Canopy/EPD.) On Windows, the Anaconda installer window gives options Add Anaconda to the System Path and also Register Anaconda as default Python version of the system. Be sure to check these boxes.

If you want Pkg.add to use a specific path for jupyter on your system (not the defaults above), you can do so by setting the JUPYTER environment variable before running Pkg.add("IJulia"). To force IJulia to use its own Miniconda installation, just set JUPYTER to the empty string, e.g. set ENV["JUPYTER"] = "" in Julia. You can run"IJulia") to re-run the installation process if needed.

On subsequent builds (e.g. when IJulia is updated via Pkg.update), it will use the same jupyter program by default, unless you override it by setting the JUPYTER environment variable, or delete the file joinpath(Pkg.dir("IJulia"), "deps", "JUPYTER").

Running the IJulia Notebook

In Julia, at the julia> prompt, you can type

using IJulia

to launch the IJulia notebook in your browser. You can use notebook(detached=true) to launch a notebook server in the background that will persist even when you quit Julia.

Alternatively, you can run

jupyter notebook

from the command line (the Terminal program in MacOS or the Command Prompt in Windows). Note that if you installed jupyter via automated Miniconda installer in Pkg.add, above, then jupyter may not be in your PATH; type import Conda; Conda.SCRIPTDIR in Julia to find out where Conda installed jupyter.

A "dashboard" window like this should open in your web browser. Click on the New button and choose the Julia option to start a new "notebook". A notebook will combine code, computed results, formatted text, and images, just as in IPython. You can enter multiline input cells and execute them with shift-ENTER, and the menu items are mostly self-explanatory. Refer to the the IPython documentation for more information.

Updating Julia and IJulia

Julia is improving rapidly, so it won't be long before you want to update to a more recent version. To update the packages only, keeping Julia itself the same, just run:


at the Julia prompt (or in IJulia).

If you download and install a new version of Julia from the Julia web site, you will also probably want to update the packages with Pkg.update() (in case newer versions of the packages are required for the most recent Julia). In any case, if you install a new Julia binary (or do anything that changes the location of Julia on your computer), you must update the IJulia installation (to tell Jupyter where to find the new Julia) by running"IJulia")

at the Julia command line (important: not in IJulia).


  • If you ran into a problem with the above steps, after fixing the problem you can type to try to rerun the install scripts.
  • If you tried it a while ago, try running Pkg.update() and try again: this will fetch the latest versions of the Julia packages in case the problem you saw was fixed. Run"IJulia") if your Julia version may have changed. If this doesn't work, you could try just deleting the whole .julia directory in your home directory (on Windows, it is called AppData\Roaming\julia\packages in your home directory) via rm(Pkg.dir(),recursive=true) in Julia and re-adding the packages.
  • On MacOS, you currently need MacOS 10.7 or later; MacOS 10.6 doesn't work (unless you compile Julia yourself, from source code).
  • Internet Explorer 8 (the default in Windows 7) or 9 don't work with the notebook; use Firefox (6 or later) or Chrome (13 or later). Internet Explorer 10 in Windows 8 works (albeit with a few rendering glitches), but Chrome or Firefox is better.
  • If the notebook opens up, but doesn't respond (the input label is In[*] indefinitely), try creating a new Python notebook (not Julia) from the New button in the Jupyter dashboard, to see if 1+1 works in Python. If it is the same problem, then probably you have a firewall running on your machine (this is common on Windows) and you need to disable the firewall or at least to allow the IP address (For the Sophos endpoint security software, go to "Configure Anti-Virus and HIPS", select "Authorization" and then "Websites", and add to "Authorized websites"; finally, restart your computer.)
  • Try running ipython --version and make sure that it prints 3.0.0 or larger; earlier versions of IPython are no longer supported by IJulia.
  • You can try setting ENV["JUPYTER"]="";"IJulia") to force IJulia to use its own Conda-based Jupyter version.

Low-level Information

Using older IPython versions

While we strongly recommend using IPython version 3 or later (note that this has nothing to do with whether you use Python version 2 or 3), we recognize that in the short term some users may need to continue using IPython 2.x. You can do this by checkout out the ipython2 branch of the IJulia package:

Pkg.checkout("IJulia", "ipython2")"IJulia")

Clearing output

Analogous to the IPython.display.clear_output() function in IPython, IJulia provides a function:


to clear the output from the current input cell. If the optional wait argument is true, then the front-end waits to clear the output until new output is available to replace it (to minimize flickering). This is useful to make simple animations, via repeated calls to IJulia.clear_output(true) followed by calls to display(...) to display a new animation frame.

Default display size

When Julia displays a large data structure such as a matrix, by default it truncates the display to a given number of lines and columns. In IJulia, this truncation is to 30 lines and 80 columns by default. You can change this default by the LINES and COLUMNS environment variables, respectively, which can also be changed within IJulia via ENV (e.g. ENV["LINES"] = 60). (Like in the REPL, you can also display non-truncated data structures via print(x).)

Manual installation of IPython

First, you will need to install a few prerequisites:

  • You need version 3.0 or later of IPython, or version 4 or later of Jupyter. Note that IPython 3.0 was released in February 2015, so the version pre-packaged with operating-system distribution is likely to be too old for the next few weeks or months. Until then, you may have to install IPython manually. On Mac and Windows systems, it is currently easiest to use the Anaconda Python installer.

  • To use the IPython notebook interface, which runs in your web browser and provides a rich multimedia environment, you will need to install the jsonschema, Jinja2, Tornado, and pyzmq (requires apt-get install libzmq-dev and possibly pip install --upgrade --force-reinstall pyzmq on Ubuntu if you are using pip) Python packages. (Given the pip installer, pip install jsonschema jinja2 tornado pyzmq should normally be sufficient.) These should have been automatically installed if you installed IPython itself via easy_install or pip.

  • To use the IPython qtconsole interface, you will need to install PyQt4 or PySide.

  • You need Julia version 0.3 or later.

Once IPython 3.0+ and Julia 0.3+ are installed, you can install IJulia from a Julia console by typing:


This will download IJulia and a few other prerequisites, and will set up a Julia kernel for IPython.

If the command above returns an error, you may need to run Pkg.update(), then retry it, or possibly run"IJulia") to force a rebuild.

Other IPython interfaces

Most people will use the notebook (browser-based) interface, but you can also use the IPython qtconsole or IPython terminal interfaces by running ipython qtconsole --kernel julia-0.3 or ipython console --kernel julia-0.3, respectively. (Replace 0.3 with whatever major Julia version you are using.)

Differences from IPython

One difference from IPython is that the IJulia kernel currently does not support "magics", which are special commands prefixed with % or %% to execute code in a different language. This and other features are under consideration in the IJulia issues list.

Debugging IJulia problems

If IJulia is crashing (e.g. it gives you a "kernel appears to have died" message), you can modify it to print more descriptive error messages to the terminal: edit your IJulia/src/IJulia.jl file (in your .julia package directory) to change the line verbose = false at the top to verbose = true and const capture_stderr = true to const capture_stderr = false. Then restart the kernel or open a new notebook and look for the error message when IJulia dies