Unable to install GLMakie, StatsMakie... UndefVarError: AbstractBackend not defined


#1

Hello.

I’m trying to install StatsMakie on Windows 10 with Julia 1.0.2, but I’m getting errors:

Pkg.add(PackageSpec(url="https://github.com/JuliaPlots/GLMakie.jl.git")) 
Pkg.add(PackageSpec(url="https://github.com/JuliaPlots/Makie.jl.git")) 
Pkg.add(PackageSpec(url="https://github.com/JuliaPlots/AbstractPlotting.jl.git")) 
Pkg.add(PackageSpec(url="https://github.com/JuliaPlots/StatsMakie.jl.git")) 

and when I do
using GLMakie I get this error:

using GLMakie
[ Info: Precompiling GLMakie [e9467ef8-e4e7-5192-8a1a-b1aee30e663a]
ERROR: LoadError: UndefVarError: AbstractBackend not defined
Stacktrace:
 [1] getproperty(::Module, ::Symbol) at .\sysimg.jl:13
 [2] top-level scope at none:0
 [3] include at .\boot.jl:317 [inlined]
 [4] include_relative(::Module, ::String) at .\loading.jl:1044
 [5] include(::Module, ::String) at .\sysimg.jl:29
 [6] top-level scope at none:2
 [7] eval at .\boot.jl:319 [inlined]
 [8] eval(::Expr) at .\client.jl:393
 [9] top-level scope at .\none:3
in expression starting at C:\Users\joe\.julia\packages\GLMakie\30EXr\src\GLMakie.jl:21
ERROR: Failed to precompile GLMakie [e9467ef8-e4e7-5192-8a1a-b1aee30e663a] to C:\Users\joe\.julia\compiled\v1.0\GLMakie\nfnZR.ji.
Stacktrace:
 [1] error(::String) at .\error.jl:33
 [2] macro expansion at .\logging.jl:311 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at .\loading.jl:1190
 [4] macro expansion at .\logging.jl:309 [inlined]
 [5] _require(::Base.PkgId) at .\loading.jl:947
 [6] require(::Base.PkgId) at .\loading.jl:858
 [7] macro expansion at .\logging.jl:309 [inlined]
 [8] require(::Module, ::Symbol) at .\loading.jl:840
using Makie
WARNING: using Makie.AbstractPlotting in module Main conflicts with an existing identifier.
using StatsMakie
[ Info: Precompiling StatsMakie [9d48ccf0-4268-5716-84ff-21228f561db3]
WARNING: could not import AbstractPlotting.used_attributes into StatsMakie
WARNING: could not import AbstractPlotting.combine into StatsMakie
WARNING: could not import AbstractPlotting.to_plotspec into StatsMakie
ERROR: LoadError: UndefVarError: PlotFunc not defined
Stacktrace:
 [1] include at .\boot.jl:317 [inlined]
 [2] include_relative(::Module, ::String) at .\loading.jl:1044
 [3] include(::Module, ::String) at .\sysimg.jl:29
 [4] top-level scope at none:2
 [5] eval at .\boot.jl:319 [inlined]
 [6] eval(::Expr) at .\client.jl:393
 [7] top-level scope at .\none:3
in expression starting at C:\Users\joe\.julia\packages\StatsMakie\UTjKs\src\StatsMakie.jl:6
ERROR: Failed to precompile StatsMakie [9d48ccf0-4268-5716-84ff-21228f561db3] to C:\Users\joe\.julia\compiled\v1.0\StatsMakie\FKwQI.ji.
Stacktrace:
 [1] error(::String) at .\error.jl:33
 [2] macro expansion at .\logging.jl:311 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at .\loading.jl:1190
 [4] macro expansion at .\logging.jl:309 [inlined]
 [5] _require(::Base.PkgId) at .\loading.jl:947
 [6] require(::Base.PkgId) at .\loading.jl:858
 [7] macro expansion at .\logging.jl:309 [inlined]
 [8] require(::Module, ::Symbol) at .\loading.jl:840

I’ve tried deleting uninstalling the packages and reinstalling again, also from the regular repository (instead of git) when available, the registry folder… with no luck.


#2

Try adding master version of the package. It is documented in this link

https://nextjournal.com/sdanisch/makie-pkg3


#3

I tried this before specifying the “master” version but I have the same problem.

Anyway. If I just install from git doesn’t it automatically use the master version?


#4

not sure, when in doubt, just check it :wink: those 3 packages need to be on master!


#5

Unfortunatelly I’m still getting this error:


WARNING: could not import AbstractPlotting.used_attributes into StatsMakie
WARNING: could not import AbstractPlotting.combine into StatsMakie
WARNING: could not import AbstractPlotting.to_plotspec into StatsMakie
ERROR: LoadError: UndefVarError: PlotFunc not defined
Stacktrace:
 [1] include at .\boot.jl:317 [inlined]
 [2] include_relative(::Module, ::String) at .\loading.jl:1044
 [3] include(::Module, ::String) at .\sysimg.jl:29
 [4] top-level scope at none:2
 [5] eval at .\boot.jl:319 [inlined]
 [6] eval(::Expr) at .\client.jl:393
 [7] top-level scope at .\none:3
in expression starting at C:\Users\joe\.julia\packages\StatsMakie\UTjKs\src\StatsMakie.jl:6
ERROR: Failed to precompile StatsMakie [9d48ccf0-4268-5716-84ff-21228f561db3] to C:\Users\joe\.julia\compiled\v1.0\StatsMakie\FKwQI.ji.
Stacktrace:
 [1] error(::String) at .\error.jl:33
 [2] macro expansion at .\logging.jl:311 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at .\loading.jl:1190
 [4] macro expansion at .\logging.jl:309 [inlined]
 [5] _require(::Base.PkgId) at .\loading.jl:947
 [6] require(::Base.PkgId) at .\loading.jl:858
 [7] macro expansion at .\logging.jl:309 [inlined]
 [8] require(::Module, ::Symbol) at .\loading.jl:840

#6

If you don’t follow the recommended commands to install the master version, there is no surprise that you still get different results :wink:
That’s what you should call:

pkg"up; add AbstractPlotting#master GLMakie#master Makie#master https://github.com/JuliaPlots/StatsMakie.jl.git"

#7

but I do follow these commands:

julia> using Pkg
julia> pkg"up; add AbstractPlotting#master GLMakie#master Makie#master https://github.com/JuliaPlots/StatsMakie.jl.git"
  Updating registry at `C:\Users\joe\.julia\registries\General`
  Updating git-repo `https://github.com/JuliaRegistries/General.git`
  Updating git-repo `https://github.com/JuliaPlots/StatsMakie.jl.git`
  Updating git-repo `https://github.com/JuliaData/DataFrames.jl.git`
  Updating git-repo `https://github.com/JuliaPlots/Makie.jl.git`
  Updating git-repo `https://github.com/JuliaPlots/AbstractPlotting.jl.git`
  Updating git-repo `https://github.com/JuliaPlots/GLMakie.jl.git`
  Updating git-repo `https://github.com/JuliaLang/IJulia.jl.git`
  Updating git-repo `https://github.com/JuliaStats/GLM.jl.git`
  Updating git-repo `https://github.com/m-j-w/CpuId.jl.git`
 Resolving package versions...
  Updating `C:\Users\joe\.julia\environments\v1.0\Project.toml`
 [no changes]
  Updating `C:\Users\joe\.julia\environments\v1.0\Manifest.toml`
 [no changes]
  Updating git-repo `https://github.com/JuliaPlots/AbstractPlotting.jl.git`
  Updating git-repo `https://github.com/JuliaPlots/GLMakie.jl.git`
  Updating git-repo `https://github.com/JuliaPlots/Makie.jl.git`
  Updating git-repo `https://github.com/JuliaPlots/StatsMakie.jl.git`
[ Info: Assigning UUID 9d48ccf0-4268-5716-84ff-21228f561db3 to StatsMakie
 Resolving package versions...
  Updating `C:\Users\joe\.julia\environments\v1.0\Project.toml`
 [no changes]
  Updating `C:\Users\joe\.julia\environments\v1.0\Manifest.toml`
 [no changes]

julia> using Makie
julia> using AbstractPlotting
julia> using GLMakie
[ Info: Precompiling GLMakie [e9467ef8-e4e7-5192-8a1a-b1aee30e663a]
ERROR: LoadError: UndefVarError: AbstractBackend not defined
Stacktrace:
 [1] getproperty(::Module, ::Symbol) at .\sysimg.jl:13
 [2] top-level scope at none:0
 [3] include at .\boot.jl:317 [inlined]
 [4] include_relative(::Module, ::String) at .\loading.jl:1044
 [5] include(::Module, ::String) at .\sysimg.jl:29
 [6] top-level scope at none:2
 [7] eval at .\boot.jl:319 [inlined]
 [8] eval(::Expr) at .\client.jl:393
 [9] top-level scope at .\none:3
in expression starting at C:\Users\joe\.julia\packages\GLMakie\30EXr\src\GLMakie.jl:21
ERROR: Failed to precompile GLMakie [e9467ef8-e4e7-5192-8a1a-b1aee30e663a] to C:\Users\joe\.julia\compiled\v1.0\GLMakie\nfnZR.ji.
Stacktrace:
 [1] error(::String) at .\error.jl:33
 [2] macro expansion at .\logging.jl:311 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at .\loading.jl:1190
 [4] macro expansion at .\logging.jl:309 [inlined]
 [5] _require(::Base.PkgId) at .\loading.jl:947
 [6] require(::Base.PkgId) at .\loading.jl:858
 [7] macro expansion at .\logging.jl:309 [inlined]
 [8] require(::Module, ::Symbol) at .\loading.jl:840

julia> using StatsMakie
[ Info: Precompiling StatsMakie [9d48ccf0-4268-5716-84ff-21228f561db3]
WARNING: could not import AbstractPlotting.used_attributes into StatsMakie
WARNING: could not import AbstractPlotting.combine into StatsMakie
WARNING: could not import AbstractPlotting.to_plotspec into StatsMakie
ERROR: LoadError: UndefVarError: PlotFunc not defined
Stacktrace:
 [1] include at .\boot.jl:317 [inlined]
 [2] include_relative(::Module, ::String) at .\loading.jl:1044
 [3] include(::Module, ::String) at .\sysimg.jl:29
 [4] top-level scope at none:2
 [5] eval at .\boot.jl:319 [inlined]
 [6] eval(::Expr) at .\client.jl:393
 [7] top-level scope at .\none:3
in expression starting at C:\Users\joe\.julia\packages\StatsMakie\UTjKs\src\StatsMakie.jl:6
ERROR: Failed to precompile StatsMakie [9d48ccf0-4268-5716-84ff-21228f561db3] to C:\Users\joe\.julia\compiled\v1.0\StatsMakie\FKwQI.ji.
Stacktrace:
 [1] error(::String) at .\error.jl:33
 [2] macro expansion at .\logging.jl:311 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at .\loading.jl:1190
 [4] macro expansion at .\logging.jl:309 [inlined]
 [5] _require(::Base.PkgId) at .\loading.jl:947
 [6] require(::Base.PkgId) at .\loading.jl:858
 [7] macro expansion at .\logging.jl:309 [inlined]
 [8] require(::Module, ::Symbol) at .\loading.jl:840

What am I doing wrong?


#8

Hi Juan,

I don’t understand why you typing in using Pkg should not pressing ] in the REPL enough? Once I am in that mode I am typing exactly what you have done above, which works for me after fixing some issues specific to MacOSX platform.

From the logging the error starts from line 21 in GLMakie.jl which is

struct GLBackend <: AbstractPlotting.AbstractBackend
end

The errors say that AbstractBackend is not defined. Can you try something like pkg" build AbstractPlotting and type something like

using AbstractPlotting

AbstractPlotting.AbstractBackend

and see what happens.


#9

I also tried with ] instead, it’s the same, but I get the same message in two computers, one with Windows 10 and another one with Window 7.
The installation itself doesn’t produce any error, but when I do “using” the compilation fails.


#10

Did you try

using AbstractPlotting

AbstractPlotting.AbstractBackend

#11
julia> using AbstractPlotting

julia> AbstractPlotting.AbstractBackend
ERROR: UndefVarError: AbstractBackend not defined

#12

This means that the problem is that somehow AbstractBackend is not defined in AbstractPlotting which is really bizarre because clearly in the package AbstractPlotting AbstractBackend is defined. You can actually go in the AbstractPlotting package and see for yourself. In display.jl

struct PlotDisplay <: AbstractDisplay end

abstract type AbstractBackend end
function backend_display end

what version of Julia are you using?


#13

More people have the same problem:

I’m using Julia 1.0.2 on Windows. (Today Windows 10, but I have the same problema at work with Windows 7).


#14

I can find a AbstractPlotting folder with several subfolders containing a display.jl file. I guess they have been created after each installation.

The content of the newest one is:

struct PlotDisplay <: AbstractDisplay end

abstract type AbstractBackend end
function backend_display end

"""
Currently available displays by backend
"""
const available_backends = AbstractBackend[]
const current_backend = Ref{Union{Missing,AbstractBackend}}(missing)
const use_display = Ref{Bool}(true)

function inline!(inline = true)
    use_display[] = !inline
end

function register_backend!(backend::AbstractBackend)
    push!(available_backends, backend)
    if(length(available_backends) == 1)
        current_backend[] = backend
    end
    nothing
end


const has_ffmpeg = Ref(false)

function __init__()
    pushdisplay(PlotDisplay())
    has_ffmpeg[] = try
        success(`ffmpeg -h`)
    catch
        false
    end
end

function Base.display(d::PlotDisplay, scene::Scene)
    use_display[] || throw(MethodError(display, (d, scene)))
    try
        return backend_display(current_backend[], scene)
    catch ex
        if ex isa MethodError && ex.f in (backend_display, backend_show)
            throw(MethodError(display, (d, scene)))
        else
            rethrow()
        end
    end
end

Base.showable(mime::MIME, scene::Scene) = backend_showable(current_backend[], mime, scene)

# have to be explicit with mimetypes to avoid ambiguity

function backend_show end
for M in (MIME"text/plain", MIME)
    @eval function Base.show(io::IO, m::$M, scene::Scene)
        res = get(io, :juno_plotsize, size(scene))
        resize!(scene, res...)
        update!(scene)
        return AbstractPlotting.backend_show(current_backend[], io, m, scene)
    end
end

function backend_showable(backend, m::MIME, scene::Scene)
    hasmethod(backend_show, Tuple{typeof(backend), IO, typeof(m), typeof(scene)})
end

# fallback show when no backend is selected
function backend_show(backend, io::IO, ::MIME"text/plain", scene::Scene)
    println(io, "Scene ($(size(scene, 1))px, $(size(scene, 2))px):")
    println(io, "events:")
    for field in fieldnames(Events)
        println(io, "    ", field, ": ", to_value(getfield(scene.events, field)))
    end
    println(io, "plots:")
    for plot in scene.plots
        println(io, "   *", typeof(plot))
    end
    print(io, "subscenes:")
    for subscene in scene.children
        print(io, "\n   *scene($(size(subscene, 1))px, $(size(subscene, 2))px)")
    end
    return
end

function backend_show(backend, io::IO, ::MIME"text/plain", plot::Combined)
    println(io, typeof(plot))
    println(io, "plots:")
    for p in plot.plots
        println(io, "   *", typeof(p))
    end
    print(io, "attributes:")
    for (k, v) in theme(plot)
        print(io, "\n  $k : $(typeof(v))")
    end
end

function Base.show(io::IO, ::MIME"text/plain", plot::Atomic)
    println(io, typeof(plot))
    print(io, "attributes:")
    for (k, v) in theme(plot)
        print(io, "\n  $k : $(typeof(to_value(v)))")
    end
end




# Stepper for generating progressive plot examples
mutable struct Stepper
    scene::Scene
    folder::String
    step::Int
end

function Stepper(scene, path)
    ispath(path) || mkpath(path)
    Stepper(scene, path, 1)
end

function FileIO.save(filename::String, scene::Scene)
    open(filename, "w") do s
        show(IOContext(s, :full_fidelity => true), MIME"image/png"(), scene)
    end
end
"""
    step!(s::Stepper)
steps through a `Makie.Stepper` and outputs a file with filename `filename-step.jpg`.
This is useful for generating progressive plot examples.
"""
function step!(s::Stepper)
    FileIO.save(joinpath(s.folder, basename(s.folder) * "-$(s.step).jpg"), s.scene)
    s.step += 1
    return s
end


"""
Record all window events that happen while executing function `f`
for `scene` and serializes them to `path`.
"""
function record_events(f, scene::Scene, path::String)
    display(scene)
    result = Vector{Pair{Float64, Pair{Symbol, Any}}}()
    for field in fieldnames(Events)
        on(getfield(scene.events, field)) do value
            value = isa(value, Set) ? copy(value) : value
            push!(result, time() => (field => value))
        end
    end
    f()
    open(path, "w") do io
        serialize(io, result)
    end
end


"""
Replays the serialized events recorded with `record_events` in `path` in `scene`.
"""
replay_events(scene::Scene, path::String) = replay_events(()-> nothing, scene, path)
function replay_events(f, scene::Scene, path::String)
    display(scene)
    events = open(io-> deserialize(io), path)
    sort!(events, by = first)
    for i in 1:length(events)
        t1, (field, value) = events[i]
        field == :mousedrag && continue
        if field == :mousebuttons
            Base.invokelatest() do
                getfield(scene.events, field)[] = value
            end
        else
            Base.invokelatest() do
                getfield(scene.events, field)[] = value
            end
        end
        f()
        yield()
        if i < length(events)
            t2, (field, value) = events[i + 1]
            # min sleep time 0.001
            (t2 - t1 > 0.001) && sleep(t2 - t1)
        end
    end
end

struct RecordEvents
    scene::Scene
    path::String
end

function Base.display(d::PlotDisplay, re::RecordEvents)
    display(d, re.scene)
end


struct VideoStream
    io
    process
    screen
    path::String
end


"""
    VideoStream(scene::Scene, dir = mktempdir(), name = "video")

returns a stream and a buffer that you can use to not allocate for new frames.
Use `add_frame!(stream, window, buffer)` to add new video frames to the stream.
Use `save(stream)` to save the video to 'dir/name.mkv'. You can also call
`save(stream, "mkv")`, `save(stream, "mp4")`, `save(stream, "gif")` or `save(stream, "webm")` to convert the stream to those formats.
"""
function VideoStream(scene::Scene)
    if !has_ffmpeg[]
        error("You can't create a video stream without ffmpeg installed.
         Please install ffmpeg, e.g. via https://ffmpeg.org/download.html.
         When you download the binaries, please make sure that you add the path to your PATH
         environment variable.
         On unix you can install ffmpeg with `sudo apt-get install ffmpeg`.
        ")
    end
    #codec = `-codec:v libvpx -quality good -cpu-used 0 -b:v 500k -qmin 10 -qmax 42 -maxrate 500k -bufsize 1000k -threads 8`
    dir = mktempdir()
    path = joinpath(dir, "$(gensym(:video)).mkv")
    screen = backend_display(current_backend[], scene)
    AbstractPlotting.update!(scene)
    _xdim, _ydim = widths(pixelarea(scene)[])
    xdim = _xdim % 2 == 0 ? _xdim : _xdim + 1
    ydim = _ydim % 2 == 0 ? _ydim : _ydim + 1
    process = open(`ffmpeg -loglevel quiet -f rawvideo -pixel_format rgb24 -r 24 -s:v $(xdim)x$(ydim) -i pipe:0 -vf vflip -y $path`, "w")
    VideoStream(process.in, process, screen, abspath(path))
end

function colorbuffer(x)
    error("colorbuffer not implemented for screen $(typeof(x))")
end

"""
Adds a video frame to the VideoStream
"""
function recordframe!(io::VideoStream)
    #codec = `-codec:v libvpx -quality good -cpu-used 0 -b:v 500k -qmin 10 -qmax 42 -maxrate 500k -bufsize 1000k -threads 8`
    frame = colorbuffer(io.screen)
    _xdim, _ydim = size(frame)
    xdim = _xdim % 2 == 0 ? _xdim : _xdim + 1
    ydim = _ydim % 2 == 0 ? _ydim : _ydim + 1
    frame_out = fill(RGB{N0f8}(1, 1, 1), ydim, xdim)
    for x in 1:_xdim, y in 1:_ydim
        c = frame[(_xdim + 1) - x, y]
        frame_out[y, x] = RGB{N0f8}(c)
    end
    write(io.io, frame_out)
    return
end

"""
    save(path::String, io::VideoStream)

Flushes the video stream and converts the file to the extension found in `path` which can
be `mkv` is default and doesn't need convert, `gif`, `mp4` and `webm`.
`mp4` is recommended for the internet, since it's the most supported format.
`webm` yields the smallest file size, `mp4` and `mk4` are marginally bigger and `gif`s are up to
6 times bigger with same quality!
"""
function save(path::String, io::VideoStream)
    close(io.process)
    wait(io.process)
    p, typ = splitext(path)
    if typ == ".mkv"
        cp(io.path, out)
    elseif typ == ".mp4"
        run(`ffmpeg -loglevel quiet -i $(io.path) -c:v libx264 -preset slow -crf 24 -pix_fmt yuv420p -c:a libvo_aacenc -b:a 128k -y $path`)
    elseif typ == ".webm"
        run(`ffmpeg -loglevel quiet -i $(io.path) -c:v libvpx-vp9 -threads 16 -b:v 2000k -c:a libvorbis -threads 16 -vf scale=iw:ih -y $path`)
    elseif typ == ".gif"
        filters = "fps=15,scale=iw:ih:flags=lanczos"
        palette_path = dirname(io.path)
        pname = joinpath(palette_path, "palette.bmp")
        isfile(pname) && rm(pname, force = true)
        run(`ffmpeg -loglevel quiet -i $(io.path) -vf "$filters,palettegen" -y $pname`)
        run(`ffmpeg -loglevel quiet -i $(io.path) -i $pname -lavfi "$filters [x]; [x][1:v] paletteuse" -y $path`)
        rm(pname, force = true)
    else
        rm(io.path)
        error("Video type $typ not known")
    end
    rm(io.path)
    return path
end


"""
    record(func, scene, path)
usage:
"example
    record(scene, "test.gif") do io
        for i = 1:100
            scene.plots[:color] = ...# animate scene
            recordframe!(io) # record a new frame
        end
    end
"
"""
function record(func, scene, path)
    io = VideoStream(scene)
    func(io)
    save(path, io)
end

"""
    record(func, scene, path, iter)
usage:
"example
    record(scene, "test.gif", 1:100) do i
        scene.plots[:color] = ...# animate scene
    end
"
"""
function record(func, scene, path, iter)
    io = VideoStream(scene)
    for i in iter
        t1 = time()
        func(i)
        recordframe!(io)
        diff = (1/24) - (time() - t1)
        if diff > 0.0
            sleep(diff)
        else
            yield()
        end
    end
    save(path, io)
end



function Base.show(io::IO, mime::MIME"text/html", vs::VideoStream)
    mktempdir() do dir
        path = finish(vs, joinpath(dir, "video.mp4"))
        print(
            io,
            """<video autoplay controls><source src="data:video/x-m4v;base64,""",
            base64encode(open(read, path)),
            """" type="video/mp4"></video>"""
        )
    end
end


#15

Alright, I have one last suggestion. This suggestion is similar to the last post in

Remove all the package so that you only have display.jl file.

pkg" rm  Makie AbstractPlotting GLMakie; gc 
pkg" add Makie#master AbstractPlotting#master GLMakie#master 

If this fail, then I am run out of idea :(. T


#16

OK, I’ going to try again. Thanks.

Anyway I’m confused because you insist in that syntax.

Don’t this two lines produce the same result?
pkg" add Makie#master
and
Pkg.add(PackageSpec(name="Makie", rev="master"))

The second way is just the new syntax. Isn’t it?


#17

The second way is just the new syntax. Isn’t it?

I don’t think you would say, that it’s the new syntax - ] add Makie#master is definitely the official way - I think the PlotSpec is pretty much just the lower level version of this.
If you execute exactly those commands and abstractbackend isn’t defined, it’s 99% sure that you’re not on master of AbstractPlotting - for whatever reason :wink: Not sure what Pkg3 is doing in your case… But I guess rm + gc + add could help


#18

Look at
https://docs.julialang.org/en/v1/stdlib/Pkg/index.html#Pkg.add

Pkg.add("Example") # Add a package from registry
Pkg.add(PackageSpec(name="Example", version="0.3")) # Specify version
Pkg.add(PackageSpec(url="https://github.com/JuliaLang/Example.jl", rev="master")) # From url
Pkg.add(PackageSpec(url="/remote/mycompany/juliapackages/OurPackage"))` # From path (has to be a gitrepo)

I think I will wait some weeks for a new version or changes.
I’ve already tried rm, gc and adding several times, with no luck.
The add process doesn’t produce any error, the problem comes when I use “using”.


#19

yes, it is a documented function! Still, it’s rather for CI - locally the preferred way is ]add Package#master.
If your Pkg refuses to install the version you ask it to, i have little hope that this will be solved by a new version :wink:
What’s the output of ]st?