A Julia debugger.
Note: If you are looking for the docs for the Juno IDE debugger, see this link instead
Starting the debugger interface
The debug interface is entered using the
using Debugger function foo(n) x = n+1 ((BigInt[1 1; 1 0])^x)[2,1] end @enter foo(20)
This interface allows for manipulating program execution, such as stepping in and out of functions, line stepping, showing local variables, setting breakpoints and evaluating code in the context of functions.
Below, square brackets denote optional arguments.
o: open the current line in an editor
q: quit the debugger, returning
C: toggle compiled mode
L: toggle showing lowered code instead of source code
-: increase / decrease the number of lines of source code shown
n: step to the next line
u [i::Int]: step until line
ior the next line past the current line
s: step into the next call
so: step out of the current call
c: continue execution until a breakpoint is hit
f [i::Int]: go to the
i-th function in the call stack (stepping is only possible in the function at the top of the call stack)
up/down [i::Int]go up or down one or
ifunctions in the call stack
nc: step to the next call
se: step one expression step
si: same as
sebut step into a call if a call is the next expression
sg: step into a generated function
st: show the "status" (current function, source code and current expression to run)
bt: show a backtrace
fr [i::Int]: show all variables in the current or
stuffin the current function's context
w add expr: add an expression to the watch list
w: show all watch expressions evaluated in the current function's context
w rm [i::Int]: remove all or the
i:th watch expression
bp add "file.jl":line [cond]: add a breakpoint att file
bp add func [:line] [cond]: add a breakpoint to function
line(defaulting to first line) with condition
bp add func(::Float64, Int)[:line] [cond]: add a breakpoint to methods matching the signature at line
line(defaulting to first line) with condition
bp add func(x, y)[:line] [cond]: add a breakpoint to the method matching the types of the local variable
yetc with condition
bp add line [cond]add a breakpoint to
lineof the file of the current function with condition
bpshow all breakpoints
bp rm [i::Int]: remove all or the
bp toggle [i::Int]: toggle all or the
bp disable [i::Int]: disable all or the
bp enable [i::Int]: enable all or the
bp on/off error- turn on or off break on error
bp on/off throw- turn on or off break on throw
An empty command will execute the previous command.
To add and manipulate breakpoints, either the
bp add command in the debug interface or the JuliaInterpreter breakpoint API, documented here
can be used.
It is common to want to run a function until a breakpoint is hit. Therefore, the "shortcut macro"
@run is provided which is equivalent
of starting the debug mode with
@enter and then executing the continue command (
julia> using Debugger julia> breakpoint(abs); julia> @run sin(2.0) Hit breakpoint: In abs(x) at float.jl:522 >522 abs(x::Float64) = abs_float(x) About to run: (abs_float)(2.0) 1|debug> bt  abs(x) at float.jl:522 | x::Float64 = 2.0  sin(x) at special/trig.jl:30 | x::Float64 = 2.0 | T::DataType = Float64
Breakpoint on error
It is possible to halt execution when an error is thrown. This is done by calling the exported function
julia> using Debugger julia> break_on(:error) julia> f() = "αβ"; julia> @run f() Breaking for error: ERROR: StringIndexError("αβ", 2) In string_index_err(s, i) at strings/string.jl:12 >12 @noinline string_index_err(s::AbstractString, i::Integer) = About to run: (throw)(StringIndexError("αβ", 2)) 1|debug> bt  string_index_err(s, i) at strings/string.jl:12 | s::String = "αβ" | i::Int64 = 2  getindex_continued(s, i, u) at strings/string.jl:218 | s::String = "αβ" | i::Int64 = 2 | u::UInt32 = 0xb1000000 | val::Bool = false  getindex(s, i) at strings/string.jl:211 | s::String = "αβ" | i::Int64 = 2 | b::UInt8 = 0xb1 | u::UInt32 = 0xb1000000  f() at REPL:1 julia> JuliaInterpreter.break_off(:error) julia> @run f() ERROR: StringIndexError("αβ", 2) Stacktrace: [...]
Place breakpoints in source code
It is sometimes more convenient to choose in the source code when to break. This is done for instance in Matlab/Octave with
keyboard, and in R with
browser(). You can use the
@bp macro to do this:
julia> using Debugger julia> function f(x) if x < 0 @bp else println("All good!") end end f (generic function with 1 method) julia> @run f(2) All good! julia> @run f(-2) Hit breakpoint: In f(x) at REPL:2 1 function f(x) 2 if x < 0 >3 @bp 4 else 5 println("All good!") 6 end 7 end About to run: return 1|debug> bt  f(x) at REPL:3 | x::Int64 = -2
In order to fully support breakpoints, the debugger interprets all code, even code that is stepped over.
Currently, there are cases where the interpreter is too slow for this to be feasible.
A workaround is to use "compiled mode" which is toggled by pressing
C in the debug REPL mode (note the change of prompt color).
When using compiled mode, code that is stepped over will be executed
by the normal julia compiler and run just as fast as normally.
The drawback is of course that breakpoints in code that is stepped over are missed.
The source code preview is syntax highlighted and this highlighting has some options.
The theme can be set by calling
theme is a Highlights.jl theme.
It can be completely turned off or alternatively, different quality settings for the colors might be chosen by calling
opt is a
The choices are
HIGHLIGHT_24_BIT. System colors works in pretty much all terminals, 256 in most terminals (with the exception of Windows)
and 24 bit in some terminals.