# Makie.jl: a GPU-backed plotting ecosystem for Julia, split across four backends

> Makie.jl is not a single plotting library but a figure-and-axis system with four rendering backends: GLMakie for native windows, WGLMakie for browsers and notebooks, CairoMakie for static vector output, RPRMakie for raytracing. This article covers what each one is for, how to install one, and where the model costs you time.

**MakieOrg/Makie.jl** — Interactive data visualizations and plotting in Julia

- Repository: https://github.com/MakieOrg/Makie.jl
- Website: https://docs.makie.org/stable
- Stars: 2,813 · Forks: 395
- Language: Julia
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/makieorg-makie-jl

## What Makie.jl actually replaces in a Julia plotting workflow

Most Julia plotting starts with a function that takes arrays and returns a picture. Makie.jl starts one level lower: you build a figure, place axes inside it, and add plot objects to those axes. The README's parabola example shows the shape of that call, where lines() takes the data plus keyword groups for axis labels and figure size, and axislegend() is a separate call that attaches a legend to the current axis rather than being a parameter of the plot.

That indirection is the point. A figure is a data structure you can keep, restyle and re-render, not a one-shot image. The README describes the project as an "interactive data visualization and plotting ecosystem for the Julia programming language," available on Windows, Linux and Mac. The word ecosystem is doing real work: the core Makie package defines the figure, axis and plot types, while the four backend packages decide how those types reach a screen or a file.

Who this is for: Julia users who need figures that stay interactive while they explore data, or who need the same figure to serve as a GUI element. The README states you can use Makie to "interactively explore your data and create simple GUIs in native windows or web browsers." That is a different audience from someone who wants a chart pasted into a report and never touched again.

## The four backends decide what your figure becomes

The backend split is the architectural fact that shapes everything else. The README lists four: GLMakie for "interactive OpenGL in native OS windows," WGLMakie for "interactive WebGL in browsers, IDEs, notebooks," CairoMakie for "static 2D vector graphics and images," and RPRMakie for "raytracing."

Each backend re-exports all of Makie.jl, so the README states you do not have to install or load the core package explicitly. In practice that means your using statement names the backend, and the figure API arrives with it. The trade-off is that the backend is not a rendering preference you flip at save time. It is a dependency you choose up front, and it determines whether the figure opens a window, appears inline in a notebook, or writes a file. GLMakie and WGLMakie exist for the interactive case; CairoMakie exists for the export case, and the README specifically ties it to "high-quality vector graphics." RPRMakie is the outlier, aimed at "physically accurate lighting" rather than data clarity.

The repository layout confirms the split is structural, not cosmetic: GLMakie/, WGLMakie/, CairoMakie/ and RPRMakie/ are top-level directories alongside Makie/ in the monorepo. They are separate packages built from one tree, which is why the development instructions ask you to dev all of them together.

## Installing Makie.jl and drawing a first plot

Installation goes through the Julia package manager. The README's example adds GLMakie, the native-window backend, from the pkg prompt:

```julia
julia>]
pkg> add GLMakie
```

The README then suggests checking what landed with ]st GLMakie, and loading it with using GLMakie. Because the backend re-exports Makie.jl, that single using line is enough to reach the plotting functions.

The README's simplest complete example is a parabola written with lines(), with axis and figure settings passed as keyword groups and the legend added afterwards:

```julia
x = 1:0.1:10
fig = lines(x, x.^2; label = "Parabola",
    axis = (; xlabel = "x", ylabel = "y", title ="Title"),
    figure = (; size = (800,600), fontsize = 22))
axislegend(; position = :lt)
save("./images/parabola.png", fig)
fig
```

What you should see: fig holds the figure object, axislegend() places a legend in the left-top position, save() writes the PNG path given as its first argument, and the final bare fig returns the object to the REPL so the backend can display it. Note that the same snippet both saves a file and returns the figure, which is why a GLMakie session can produce a PNG and a window from one plot.

The README shows a second, denser example using with_theme() to set a patch color gradient, band!() to draw filled ranges, and LaTeX-style strings like L"sin(x)" for labels. It also demonstrates translate!() to move a line into the foreground and limits!() to pin the axis range. Those names are worth noting because they are the vocabulary the rest of the documentation builds on.

## Where the backend model costs you: export, sharing and rendering surprises

The clearest limitation is that no single backend covers every use case, and the README does not present one as doing so. If you want an interactive window and a publication-quality vector file, you are choosing between two packages, and the figure code may need to be reloaded under a different backend. The README does not document a supported path for switching a live figure between GLMakie and CairoMakie, so treat that as an open question rather than a feature.

There is a second cost that follows from the first. Because the backend is a package dependency, the interactive path pulls in OpenGL or WebGL machinery even for users who only ever look at a static image. That is dependency weight you pay for the option of interactivity, not for the output itself.

RPRMakie is the narrowest case. Raytracing with physically accurate lighting is a rendering goal, not a data-visualization goal, and the README gives it one clause of description with no example. If your task is a heatmap for a paper, RPRMakie is the wrong tool and the README offers nothing to suggest otherwise.

Finally, the README's examples assume an environment that can display or save a figure. It does not cover headless servers, CI rendering, or what happens when a backend cannot find a display. Those are the situations where a plotting stack with a rendering dependency diverges most from a pure-function plotting library, and the README is silent on them.

## Makie.jl compared with Plots.jl: figure objects versus plotting commands

The comparison people search for is Makie.jl versus Plots.jl, and the difference is architectural rather than a matter of which produces prettier lines. Plots.jl is built around plotting commands that dispatch to a backend selected at runtime, so a single call produces a plot and the backend is largely an implementation detail. Makie.jl inverts that: the figure, axes and plot objects are explicit, and the backend is a package you install and load before anything renders.

That inversion is why the README's examples pass axis and figure settings as named tuples inside the plot call, and why legend placement is a separate axislegend() invocation rather than a keyword on lines(). You are composing a scene. The payoff is that the same scene can be interactive, embedded, or exported depending on which backend is loaded. The cost is more ceremony per plot and a dependency decision you cannot defer.

For a one-off chart from a script, Plots.jl's model asks less of you. For a figure you will restyle repeatedly, or one that needs to respond to input in a window or browser, Makie.jl's explicit object model is the reason to accept the extra setup.

## Maintenance, releases and the MIT licence

Makie.jl is not archived, and its last push was on 2026-09-24. Recent releases are v0.24.15 on 2026-09-19, v0.24.14 on 2026-09-03, and v0.24.13 on 2026-07-07, so the cadence visible in the release list is roughly every few weeks with a longer gap in July. The version line is still 0.24.x, which in Julia's convention means the package has not reached 1.0 and minor releases can carry breaking changes.

The upgrade cost follows from the monorepo layout. Makie and its backends live in one tree, and the README's development instructions ask you to dev Makie, GLMakie, CairoMakie, WGLMakie and RPRMakie together, plus ReferenceTests to run the test suite. If you develop against the repository rather than the registered packages, you inherit that multi-package setup. If you only consume the registered packages, your upgrade surface is the backend you installed, but a backend bump can still move the core API with it.

The licence is MIT, declared in LICENSE.md at the repository root and shown as a badge in the README. MIT is permissive: it allows reuse in closed-source work provided the copyright notice and permission notice are preserved. That is a summary of the licence text, not legal advice; read LICENSE.md for the terms that apply to you. The README also asks that scientific publications cite the JOSS paper by Danisch and Krumbiegel (2021), which is a citation request rather than a licence condition.

## Conclusion

Adopt Makie.jl if you already work in Julia and want one figure object that can be explored in a window, embedded in a notebook, or saved as vector output without rewriting the plot. Do not adopt it if you need a quick throwaway chart from a non-Julia pipeline, or if you want a single install that covers every output mode. Before committing, verify which backend your target environment supports, confirm the installed backend version with ]st GLMakie or its equivalent, and run one plot end to end in the environment where it will actually be displayed, because the backend choice determines whether the figure opens a window, renders in a browser, or writes a file.

## FAQ

### Is Makie a name, and where does the name Makie.jl come from?

The README states that Makie is derived from the Japanese word Maki-e, a technique of sprinkling lacquer with gold and silver powder, and gives the pronunciation as Mah-kee. The project applies the metaphor to data, which the README calls the gold and silver of our age.

### How does Makie.jl compare with Plots.jl?

The README does not compare the two. What it does document is that Makie.jl is split into four backend packages, GLMakie, WGLMakie, CairoMakie and RPRMakie, each re-exporting Makie.jl, so the backend is a package you install and load rather than a setting inside the plot call.

### Which Makie.jl backend should I install for a first plot?

The README's installation section says to choose one or more backend packages and shows adding GLMakie, which provides interactive OpenGL in native OS windows. CairoMakie is the backend the README describes for static 2D vector graphics and images, and WGLMakie for WebGL in browsers, IDEs and notebooks.

### Does installing a Makie.jl backend also install Makie.jl itself?

Yes, according to the README, which states that each backend re-exports all of Makie.jl so you do not have to install or load it explicitly. In the README's example, using GLMakie is enough to start plotting.

### How do I check which version of a Makie.jl backend I have installed?

The README's installation section shows running ]st GLMakie at the Julia package manager prompt to check the installed version of that backend.

## Sources

- [License: MIT](https://github.com/MakieOrg/Makie.jl/blob/master/LICENSE)
- [MakieOrg/Makie.jl on GitHub](https://github.com/MakieOrg/Makie.jl)
- [Project website](https://docs.makie.org/stable)
- [README](https://github.com/MakieOrg/Makie.jl/blob/master/README.md)
- [Releases](https://github.com/MakieOrg/Makie.jl/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/makieorg-makie-jl