diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6275bff231..2309271b5e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -56,7 +56,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.6'
+          - '1'
         os:
           - ubuntu-18.04
         arch:
diff --git a/.gitignore b/.gitignore
index 3e4f498ac9..8954718ea4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ Manifest.toml
 /.benchmarkci
 *.osm.cache
 src/update_*
+agents_visualizations.md
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8d99496179..468c4e333d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,17 @@
+# v5
+- Agents.jl + InteractiveDynamics.jl now support native plotting for
+  open street map spaces, which is integrated in all interactive apps as well!
+- Most examples have been moved to AgentsExampleZoo.jl. Additional examples will now be added there.
+
+## BREAKING
+- Plotting, animating, and interacting GUIs based on InteractiveDynamics.jl have changed. Please see online docs for the new format.
+- LightGraphs.jl dependency is now replaced by Graphs.jl
+- OpenStreetMapX.jl dependency now replaced by LightOSM.jl. This mean initializing the space is different, and some API methods have changed. Check documentation for more details. Note that this also means checkpoints using the old `OpenStreetMapSpace` cannot be read in this version.
+- Functions for planning and moving along routes have had their names unified across Pathfinding and OpenStreetMap modules. The names now are `plan_route!` and `move_along_route!` and are accessible from the top level scope.
+- `OSM.intersection` is renamed to `OSM.nearest_node`
+- `OSM.road` is renamed to `OSM.nearest_road`
+- `latlon` is removed in favor of `OSM.lonlat`
+
 # v4.5.4
 - Previously `nearby_ids` with `r=0` for `GraphSpace` was undefined. Now it returns ids only in the same position as given.
 
diff --git a/CITATION.bib b/CITATION.bib
index 2f60095185..944f833412 100644
--- a/CITATION.bib
+++ b/CITATION.bib
@@ -1,12 +1,13 @@
 @article{Agents.jl,
-author = {George Datseris and Ali R. Vahdati and Timothy C. DuBois},
-title ={Agents.jl: a performant and feature-full agent-based modeling software of minimal code complexity},
-journal = {SIMULATION},
-volume = {0},
-number = {0},
-pages = {00375497211068820},
-year = {0},
-doi = {10.1177/00375497211068820},
-URL = {https://doi.org/10.1177/00375497211068820},
-eprint = {https://doi.org/10.1177/00375497211068820},
+  doi = {10.1177/00375497211068820},
+  url = {https://doi.org/10.1177/00375497211068820},
+  year = {2022},
+  month = jan,
+  publisher = {{SAGE} Publications},
+  pages = {003754972110688},
+  author = {George Datseris and Ali R. Vahdati and Timothy C. DuBois},
+  title = {Agents.jl: a performant and feature-full agent-based modeling software of minimal code complexity},
+  journal = {{SIMULATION}},
+  volume = {0},
+  number = {0},
 }
\ No newline at end of file
diff --git a/Project.toml b/Project.toml
index c8dda3216f..075e0d72f4 100644
--- a/Project.toml
+++ b/Project.toml
@@ -9,7 +9,6 @@ DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
-GraphRecipes = "bd48cda9-67a9-57be-86fa-5b3c104eda73"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819"
 LazyArtifacts = "4af54fe1-eca0-43a8-85a7-787d91b784e3"
@@ -18,7 +17,6 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 Scratch = "6c6a2e73-6563-6170-7368-637461726353"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
@@ -27,13 +25,11 @@ StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 CSV = "0.9.7, 0.10"
 DataFrames = "0.21, 0.22, 1"
 DataStructures = "0.18"
-GraphRecipes = "0.5"
 Graphs = "1.4"
 JLD2 = "0.4"
 LazyArtifacts = "1.3.0"
 LightOSM = "0.1.19"
 ProgressMeter = "1.5"
-RecipesBase = "1"
 Requires = "0.5, 0.6, 0.7, 1.0, 1.1"
 Scratch = "1"
 StatsBase = "0.32, 0.33"
diff --git a/README.md b/README.md
index 7e29e8f621..ac8503312f 100644
--- a/README.md
+++ b/README.md
@@ -23,16 +23,17 @@ Any contribution to Agents.jl is welcome! For example you can:
 
 If you use this package in a publication, please cite the paper below:
 ```
-@article{Agents2021,
-author = {George Datseris and Ali R. Vahdati and Timothy C. DuBois},
-title ={Agents.jl: a performant and feature-full agent-based modeling software of minimal code complexity},
-journal = {SIMULATION},
-volume = {0},
-number = {0},
-pages = {00375497211068820},
-year = {0},
-doi = {10.1177/00375497211068820},
-URL = {https://doi.org/10.1177/00375497211068820},
-eprint = {https://doi.org/10.1177/00375497211068820},
+@article{Agents.jl,
+  doi = {10.1177/00375497211068820},
+  url = {https://doi.org/10.1177/00375497211068820},
+  year = {2022},
+  month = jan,
+  publisher = {{SAGE} Publications},
+  pages = {003754972110688},
+  author = {George Datseris and Ali R. Vahdati and Timothy C. DuBois},
+  title = {Agents.jl: a performant and feature-full agent-based modeling software of minimal code complexity},
+  journal = {{SIMULATION}},
+  volume = {0},
+  number = {0},
 }
 ```
diff --git a/docs/Project.toml b/docs/Project.toml
index cdf2e4a774..ea2b895fd0 100644
--- a/docs/Project.toml
+++ b/docs/Project.toml
@@ -25,3 +25,6 @@ RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 SimpleWeightedGraphs = "47aef6b3-ad0c-573a-a1e2-d07658019622"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
+
+[compat]
+Documenter = "0.24.6"
\ No newline at end of file
diff --git a/docs/make.jl b/docs/make.jl
index b06a07cb2a..b141062435 100644
--- a/docs/make.jl
+++ b/docs/make.jl
@@ -27,6 +27,12 @@ for file in readdir(indir)
     Literate.markdown(joinpath(indir, file), outdir; credit = false)
 end
 
+# Also bring in visualizations from interactive dynamics docs:
+using Literate
+infile = joinpath(pkgdir(InteractiveDynamics), "docs", "src", "agents.jl")
+outdir = joinpath(@__DIR__, "src")
+Literate.markdown(infile, outdir; credit = false, name = "agents_visualizations")
+
 # %%
 # download the themes
 println("Theme-ing")
@@ -89,7 +95,7 @@ makedocs(
             "More Examples for Agents.jl" => "examples.md"
         ],
         "API" => "api.md",
-        "Plotting and interactive application" => "interact.md",
+        "Plotting and Interactivity" => "agents_visualizations.md",
         "Ecosystem Integration" => [
             "BlackBoxOptim.jl" => "examples/optim.md",
             "DifferentialEquations.jl" => "examples/diffeq.md",
diff --git a/docs/src/examples.md b/docs/src/examples.md
index f34d93885d..c78d7a3cd4 100644
--- a/docs/src/examples.md
+++ b/docs/src/examples.md
@@ -1,2 +1,2 @@
 # More Examples for Agents.jl
-In order to keep the documentation of Agents.jl lean and focused, the majority of model examples for Agents.jl are not hosted in this documentation, but rather in a different one: [Agents.jl Example Zoo]([More Examples for Agents.jl](https://juliadynamics.github.io/AgentsExampleZoo.jl/dev/)). Any kind of user-written example is welcomed to be contributed there as well!
+In order to keep the documentation of Agents.jl lean and focused, the majority of model examples for Agents.jl are not hosted in this documentation, but rather in a different one: [Agents.jl Example Zoo](https://juliadynamics.github.io/AgentsExampleZoo.jl/dev/). Any kind of user-written example is welcomed to be contributed there as well!
diff --git a/docs/src/index.md b/docs/src/index.md
index 4b92bac304..9f2d787773 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -8,8 +8,11 @@ To get started, please read the [Tutorial](@ref) page.
     If you have found this package useful, please consider starring it on [GitHub](https://github.com/JuliaDynamics/Agents.jl).
     This gives us an accurate lower bound of the (satisfied) user count.
 
-!!! tip "Latest news: Agents.jl v4.5.7"
-      * The [Tutorial](@ref) page is now also available as a YouTube video: https://youtu.be/fgwAfAa4kt0 
+!!! tip "Latest news: Agents.jl v5"
+    New Major release with a lot of improvements!
+    * New packages used for Graph and OpenStreetMap spaces: Graphs.jl and LightOSM.jl.
+    * Native plotting of `OpenStreetMapSpace` through InteractiveDynamics.jl! This includes the interactive apps!
+    * Please see the [CHANGELOG.md](https://github.com/JuliaDynamics/Agents.jl/blob/master/CHANGELOG.md) for more details!
 
 
 ## Features
@@ -91,16 +94,17 @@ You're looking for support for Agents.jl? Look no further! Here's the three thin
 If you use this package in work that leads to a publication, then please cite the paper below:
 
 ```
-@article{Agents2021,
-author = {George Datseris and Ali R. Vahdati and Timothy C. DuBois},
-title ={Agents.jl: a performant and feature-full agent-based modeling software of minimal code complexity},
-journal = {SIMULATION},
-volume = {0},
-number = {0},
-pages = {00375497211068820},
-year = {0},
-doi = {10.1177/00375497211068820},
-URL = {https://doi.org/10.1177/00375497211068820},
-eprint = {https://doi.org/10.1177/00375497211068820},
+@article{Agents.jl,
+  doi = {10.1177/00375497211068820},
+  url = {https://doi.org/10.1177/00375497211068820},
+  year = {2022},
+  month = jan,
+  publisher = {{SAGE} Publications},
+  pages = {003754972110688},
+  author = {George Datseris and Ali R. Vahdati and Timothy C. DuBois},
+  title = {Agents.jl: a performant and feature-full agent-based modeling software of minimal code complexity},
+  journal = {{SIMULATION}},
+  volume = {0},
+  number = {0},
 }
 ```
diff --git a/docs/src/interact.md b/docs/src/interact.md
deleted file mode 100644
index 512ec3726d..0000000000
--- a/docs/src/interact.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# Plotting and interactive application
-Plotting and interaction functionality comes from [`InteractiveDynamics`](https://juliadynamics.github.io/InteractiveDynamics.jl/dev/), another package of JuliaDynamics, which uses Makie.jl.
-
-Plotting, and the interactive application of Agents.jl, are _model-agnostic_ and _simple to use_. Defining simple functions that map agents to colors, and shapes, is the only thing you need to do. If you have already defined an ABM and functions for stepping the model, you typically need to write only an extra couple of lines of code to get your visualizations going. All models in the Examples showcase plotting.
-
-You need to install both `InteractiveDynamics`, as well as a plotting backend (we recommend `GLMakie`) to use the following functions.
-
-The version of `InteractiveDynamics` used in the docs is:
-```@example versions
-using Pkg
-Pkg.status("InteractiveDynamics")
-```
-
-Some parts of Agents.jl cannot be plotted yet in Makie.jl, and therefore alternatives are provided. However in the near future we hope to have moved everything to plotting with Makie.jl and not necessitate usage of Plots.jl or other libraries.
-
-## Plotting
-The following functions allow you to plot an ABM, animate it via play/pause buttons, or directly export the time evolution into a video. At the moment these functions support 2D continuous and discrete space.
-
-```@docs
-InteractiveDynamics.abm_plot
-InteractiveDynamics.abm_play
-InteractiveDynamics.abm_video
-```
-
-## Interactive application
-
-```@docs
-InteractiveDynamics.abm_data_exploration
-```
-
-Here is an example application made with [`InteractiveDynamics.abm_data_exploration`](@ref) from the [Daisyworld](@ref) example.
-
-## Graph plotting
-To plot agents existing of a [`GraphSpace`](@ref) we can't use `InteractiveDynamics` because Makie.jl does not support plotting on graphs (yet). We provide the following function in this case, which comes into scope when `using Plots`. See also the [SIR model for the spread of COVID-19](@ref) example for an application.
-```@docs
-abm_plot_on_graph
-```
-
-## Open Street Map plotting
-Plotting an open street map is also not possible with Makie.jl at the moment, but there is a Julia package that does this kind of plotting, OpenStreetMapXPlots.jl. Its usage is demonstrated in the [Zombie Outbreak](@ref) example page.
-
-## Plots.jl Recipes
-Whilst the primary method for plotting agents models is through `InteractiveDynamics`, the following Plots recipes can also be used if you prefer the Plots.jl ecosystem.
-
-Notice that these methods will emit a warning. Pass `warn = false` to suppress it.
-
-```@docs
-plotabm
-plotabm!
-```
-
diff --git a/examples/flock.jl b/examples/flock.jl
index 6c92d343ae..8fdcdeb59e 100644
--- a/examples/flock.jl
+++ b/examples/flock.jl
@@ -115,27 +115,27 @@ using InteractiveDynamics
 using CairoMakie
 CairoMakie.activate!() # hide
 
-# The great thing about [`abm_plot`](@ref) is its flexibility. We can incorporate the
+# The great thing about [`abmplot`](@ref) is its flexibility. We can incorporate the
 # direction of the birds when plotting them, by making the "marker" function `am`
 # create a `Polygon`: a triangle with same orientation as the bird's velocity.
 # It is as simple as defining the following function:
 
-const bird_polygon = Polygon(Point2f0[(-0.5, -0.5), (1, 0), (-0.5, 0.5)])
+const bird_polygon = Polygon(Point2f[(-0.5, -0.5), (1, 0), (-0.5, 0.5)])
 function bird_marker(b::Bird)
     φ = atan(b.vel[2], b.vel[1]) #+ π/2 + π
     scale(rotate2D(bird_polygon, φ), 2)
 end
 
 # Where we have used the utility functions `scale` and `rotate2D` to act on a
-# predefined polygon. We now give `bird_marker` to `abm_plot`, and notice how
+# predefined polygon. We now give `bird_marker` to `abmplot`, and notice how
 # the `as` keyword is meaningless when using polygons as markers.
 
 model = initialize_model()
-figure, = abm_plot(model; am = bird_marker)
+figure, = abmplot(model; am = bird_marker)
 figure
 
 # And let's also do a nice little video for it:
-abm_video(
+abmvideo(
     "flocking.mp4", model, agent_step!;
     am = bird_marker,
     framerate = 20, frames = 100,
diff --git a/examples/rabbit_fox_hawk.jl b/examples/rabbit_fox_hawk.jl
index 05980645b9..3b1cc0e3b5 100644
--- a/examples/rabbit_fox_hawk.jl
+++ b/examples/rabbit_fox_hawk.jl
@@ -1,10 +1,11 @@
 # # Rabbit, Fox, Hawk
 # ```@raw html
-# <video width="auto" controls autoplay loop>
-# <source src="../rabbit_fox_hawk.mp4" type="video/mp4">
+# <video width="100%" height="auto" controls autoplay loop>
+# <source src="https://raw.githubusercontent.com/JuliaDynamics/JuliaDynamics/master/videos/agents/rabbit_fox_hawk.mp4?raw=true" type="video/mp4">
 # </video>
 # ```
-# This model is much more advanced version of the [Predator-prey dynamics](https://juliadynamics.github.io/AgentsExampleZoo.jl/dev/examples/predator_prey_fast/) example. 
+
+# This model is much more advanced version of the [Predator-prey dynamics](https://juliadynamics.github.io/AgentsExampleZoo.jl/dev/examples/predator_prey_fast/) example.
 # It uses a 3-dimensional
 # [`ContinuousSpace`](@ref), a realistic terrain for the agents, and pathfinding (with multiple
 # pathfinders). It should be considered an advanced example for showcasing pathfinding.
@@ -29,11 +30,12 @@ mutable struct Animal <: AbstractAgent
     energy::Float64
 end
 
-## Some utility functions to create specific types of agents, and find the norm of a vector
+## Some utility functions to create specific types of agents,
+# and find the euclidean norm of a vector
 Rabbit(id, pos, energy) = Animal(id, pos, :rabbit, energy)
 Fox(id, pos, energy) = Animal(id, pos, :fox, energy)
 Hawk(id, pos, energy) = Animal(id, pos, :hawk, energy)
-norm(vec) = √sum(vec .^ 2)
+eunorm(vec) = √sum(vec .^ 2)
 
 # The environment is generated from a heightmap: a 2D matrix, where each value denotes the
 # height of the terrain at that point. We segregate the model into 4 regions based on the
@@ -226,7 +228,7 @@ function rabbit_step!(rabbit, model)
             all(away_direction .≈ 0.) && continue
             ## Add this to the overall direction, scaling inversely with distance.
             ## As a result, closer predators contribute more to the direction to move in
-            direction = direction .+ away_direction ./ norm(away_direction) ^ 2
+            direction = direction .+ away_direction ./ eunorm(away_direction) ^ 2
         end
         ## If the only predator is right on top of the rabbit
         if all(direction .≈ 0.)
@@ -234,7 +236,7 @@ function rabbit_step!(rabbit, model)
             chosen_position = random_walkable(rabbit.pos, model, model.landfinder, model.rabbit_vision)
         else
             ## Normalize the resultant direction, and get the ideal position to move it
-            direction = direction ./ norm(direction)
+            direction = direction ./ eunorm(direction)
             ## Move to a random position in the general direction of away from predators
             position = rabbit.pos .+ direction .* (model.rabbit_vision / 2.)
             chosen_position = random_walkable(position, model, model.landfinder, model.rabbit_vision / 2.)
@@ -370,9 +372,10 @@ end
 # The agents are color-coded according to their `type`, to make them easily identifiable in
 # the visualization.
 
-using InteractiveDynamics
-using GLMakie
-GLMakie.activate!() # hide
+# ```julia
+# using InteractiveDynamics
+# using GLMakie # CairoMakie doesn't do 3D plots
+# ```
 
 animalcolor(a) =
     if a.type == :rabbit
@@ -403,22 +406,22 @@ heightmap_url =
     "JuliaDynamics/master/videos/agents/rabbit_fox_hawk_heightmap.png"
 model = initialize_model(heightmap_url)
 
-abm_video(
-    "rabbit_fox_hawk.mp4",
-    model,
-    animal_step!,
-    model_step!;
-    resolution = (700, 700),
-    frames = 300,
-    framerate = 20,
-    ac = animalcolor,
-    as = 1.0,
-    static_preplot!
-)
+# ```juia
+# abmvideo(
+#     "rabbit_fox_hawk.mp4",
+#     model, animal_step!, model_step!;
+#     figure = (resolution = (800, 700),),
+#     frames = 300,
+#     framerate = 15,
+#     ac = animalcolor,
+#     as = 1.0,
+#     static_preplot!,
+#     title = "Rabbit Fox Hawk with pathfinding"
+# )
+# ```
 
-nothing # hide
 # ```@raw html
-# <video width="auto" controls autoplay loop>
-# <source src="../rabbit_fox_hawk.mp4" type="video/mp4">
+# <video width="100%" height="auto" controls autoplay loop>
+# <source src="https://raw.githubusercontent.com/JuliaDynamics/JuliaDynamics/master/videos/agents/rabbit_fox_hawk.mp4?raw=true" type="video/mp4">
 # </video>
 # ```
diff --git a/examples/schelling.jl b/examples/schelling.jl
index 4f13d2ceff..ddbf4e6efc 100644
--- a/examples/schelling.jl
+++ b/examples/schelling.jl
@@ -164,8 +164,10 @@ step!(model, agent_step!)
 step!(model, agent_step!, 3)
 
 # ## Visualizing the data
+# There is a dedicated tutorial for visualization, animation, and interaction for
+# agent based models. See [Visualizations and Animations for Agent Based Models](@ref).
 
-# We can use the [`abm_plot`](@ref) function to plot the distribution of agents on a
+# We can use the [`abmplot`](@ref) function to plot the distribution of agents on a
 # 2D grid at every generation, via the
 # [InteractiveDynamics.jl](https://juliadynamics.github.io/InteractiveDynamics.jl/dev/) package
 # and the [Makie.jl](http://makie.juliaplots.org/stable/) plotting ecosystem.
@@ -177,17 +179,17 @@ CairoMakie.activate!() # hide
 
 groupcolor(a) = a.group == 1 ? :blue : :orange
 groupmarker(a) = a.group == 1 ? :circle : :rect
-figure, _ = abm_plot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
 figure # returning the figure displays it
 
 # ## Animating the evolution
 
-# The function [`abm_video`](@ref) can be used to save an animation of the ABM into a
-# video. You could of course also explicitly use `abm_plot` in a `record` loop for
+# The function [`abmvideo`](@ref) can be used to save an animation of the ABM into a
+# video. You could of course also explicitly use `abmplot` in a `record` loop for
 # finer control over additional plot elements.
 
 model = initialize();
-abm_video(
+abmvideo(
     "schelling.mp4", model, agent_step!;
     ac = groupcolor, am = groupmarker, as = 10,
     framerate = 4, frames = 20,
@@ -281,7 +283,7 @@ model = initialize(; numagents = 300) # fresh model, noone happy
 model = initialize(numagents = 200, min_to_be_happy = 5, seed = 42)
 run!(model, agent_step!, 40)
 
-figure, _ = abm_plot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
 figure
 
 # Most of the agents have settled happily. Now, let's save the model.
@@ -293,7 +295,7 @@ model = AgentsIO.load_checkpoint("schelling.jld2"; scheduler = Schedulers.random
 
 # Since functions are not saved, the scheduler has to be passed while loading
 # the model. Let's now verify that we loaded back exactly what we saved.
-figure, _ = abm_plot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
 figure
 
 # For starters, let's see what happens if we add 100 more agents of group 1
@@ -303,13 +305,13 @@ for i in 1:100
 end
 
 # Let's see what our model looks like now.
-figure, _ = abm_plot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
 figure
 
 # And then run it for 40 iterations.
 run!(model, agent_step!, 40)
 
-figure, _ = abm_plot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
 figure
 
 # It looks like the agents eventually cluster again. What if the agents are of a new group?
@@ -327,13 +329,13 @@ end
 groupcolor(a) = (:blue, :orange, :green)[a.group]
 groupmarker(a) = (:circle, :rect, :cross)[a.group]
 
-figure, _ = abm_plot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
 figure
 
 # The new agents are scattered randomly, as expected. Now let's run the model.
 run!(model, agent_step!, 40)
 
-figure, _ = abm_plot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
 figure
 
 # The new agents also form their own clusters, despite being completely scattered.
diff --git a/examples/schoolyard.jl b/examples/schoolyard.jl
index d013fbfe1c..dd20ec2365 100644
--- a/examples/schoolyard.jl
+++ b/examples/schoolyard.jl
@@ -150,7 +150,7 @@ function static_preplot!(ax, model)
     CairoMakie.translate!(obj, 0, 0, 5) # be sure that the teacher will be above students
 end
 
-abm_video(
+abmvideo(
     "schoolyard.mp4", model, agent_step!, dummystep;
     framerate = 15, frames = 40,
     title = "Playgound dynamics",
diff --git a/examples/sir.jl b/examples/sir.jl
index 54554d9c3d..582e3f32ec 100644
--- a/examples/sir.jl
+++ b/examples/sir.jl
@@ -230,28 +230,35 @@ end
 nothing # hide
 
 # ## Example animation
+# At the moment [`abmplot`](@ref) does not plot `GraphSpace`s, but we can still
+# utilize the [`ABMObservable`](@ref). We do not need to collect data here,
+# only the current status of the model will be used in visualization
+using InteractiveDynamics
+using CairoMakie
+CairoMakie.activate!() # hide
+abmobs = ABMObservable(model; agent_step!)
+
+# We then initialize elements that are lifted observables from `abmobs`:
+infected_fraction(m, x) = count(m[id].status == :I for id in x) / length(x)
+infected_fractions(m) = [infected_fraction(m, ids_in_position(p, m)) for p in positions(m)]
+fracs = lift(infected_fractions, abmobs.model)
+color = lift(fs -> [cgrad(:inferno)[f] for f in fs], fracs)
+title = lift(
+    (s, m) -> "step = $(s), infected = $(round(Int, 100infected_fraction(m, allids(m))))%",
+    abmobs.s, abmobs.model
+)
 
-# First, we'll define a few variables that look over aspects of the model
-total_infected(m) = count(a.status == :I for a in allagents(m))
-infected_fraction(x) = cgrad(:inferno)[count(model[id].status == :I for id in x) / length(x)]
-s = Observable(0) # Current step
-total = Observable(total_infected(model)) # Number of infected across all cities
-color = Observable(infected_fraction.(model.space.s)) # Percentage of infected people per city
-title = lift((c, t) -> "Step = "*string(c)*", Infected = "*string(t), s, total)
-
-# Then, initialise the model and view the contagion:
+# And lastly we use them to plot things in a figure
+fig = Figure(resolution = (600, 400))
+ax = Axis(fig[1, 1]; title, xlabel = "City", ylabel = "Population")
+barplot!(ax, model.Ns; strokecolor = :black, strokewidth = 1, color)
+fig
 
-model = model_initiation(; params...)
-figure = Figure(resolution = (600, 400))
-ax = figure[1, 1] = Axis(figure; title, xlabel = "City", ylabel = "Population")
-barplot!(ax, model.Ns, strokecolor = :black, strokewidth = 1; color)
-record(figure, "covid_evolution.mp4"; framerate = 5) do io
-    for j in 1:40
+# Now we can even make an animation of it
+record(fig, "covid_evolution.mp4"; framerate = 5) do io
+    for j in 1:30
         recordframe!(io)
-        Agents.step!(model, agent_step!, 1)
-        color[] = infected_fraction.(model.space.s)
-        s[] += 1
-        total[] = total_infected(model)
+        Agents.step!(abmobs, 1)
     end
     recordframe!(io)
 end
@@ -285,14 +292,14 @@ data[1:10, :]
 
 N = sum(model.Ns) # Total initial population
 x = data.step
-figure = Figure(resolution = (600, 400))
-ax = figure[1, 1] = Axis(figure, xlabel = "steps", ylabel = "log10(count)")
+fig = Figure(resolution = (600, 400))
+ax = fig[1, 1] = Axis(fig, xlabel = "steps", ylabel = "log10(count)")
 li = lines!(ax, x, log10.(data[:, aggname(:status, infected)]), color = :blue)
 lr = lines!(ax, x, log10.(data[:, aggname(:status, recovered)]), color = :red)
 dead = log10.(N .- data[:, aggname(:status, length)])
 ld = lines!(ax, x, dead, color = :green)
-figure[1, 2] = Legend(figure, [li, lr, ld], ["infected", "recovered", "dead"], textsize = 12)
-figure
+fig[1, 2] = Legend(fig, [li, lr, ld], ["infected", "recovered", "dead"], textsize = 12)
+fig
 
 # The exponential growth is clearly visible since the logarithm of the number of infected increases
 # linearly, until everyone is infected.
diff --git a/examples/zombies.jl b/examples/zombies.jl
index 9ef445534e..3d949b628a 100644
--- a/examples/zombies.jl
+++ b/examples/zombies.jl
@@ -27,6 +27,7 @@ end
 #     id::Int
 #     pos::Tuple{Int,Int,Float64}
 #     infected::Bool
+#     speed::Float64
 # end
 # ```
 # where a tuple `(i, j, x)::Tuple{Int,Int,Float64}` means a position
@@ -57,7 +58,7 @@ function initialise(; seed = 1234)
     ## We'll add patient zero at a specific (latitude, longitude)
     start = OSM.nearest_road((51.5328328, 9.9351811), model)
     finish = OSM.nearest_node((51.530876112711745, 9.945125635913511), model)
-    
+
     speed = rand(model.rng) * 5.0 + 2.0 # Random speed from 2-7kmph
     zombie = add_agent!(start, model, true, speed)
     plan_route!(zombie, finish, model)
@@ -90,33 +91,15 @@ function agent_step!(agent, model)
 end
 
 # ## Visualising the fall of humanity
-#
-# Plotting this space in a seamless manner is a work in progress. For now we
-# use [OSMMakie.jl](https://github.com/fbanning/OSMMakie.jl) and
-# a custom routine.
-
-# using OSMMakie
+using InteractiveDynamics
 using CairoMakie
+CairoMakie.activate!() # hide
 ac(agent) = agent.infected ? :green : :black
 as(agent) = agent.infected ? 6 : 5
-
 model = initialise()
 
-# fig, ax, plot = osmplot(model.space.map)
-ids = model.scheduler(model)
-colors = Node([ac(model[i]) for i in ids])
-sizes = Node([as(model[i]) for i in ids])
-marker = :circle
-pos = Node(Point2f[OSM.latlon(model[i].pos, model) for i in ids])
-fig, _= scatter(pos; color = colors, size = sizes, marker)
+abmvideo("outbreak.mp4", model, agent_step!; framerate = 15, frames = 200, as, ac)
 
-record(fig, "outbreak.mp4", 1:200; framerate = 15) do i
-    Agents.step!(model, agent_step!, 1)
-    ids = model.scheduler(model)
-    colors[] = [ac(model[i]) for i in ids]
-    sizes[] = [as(model[i]) for i in ids]
-    pos[] = Point2f[OSM.latlon(model[i].pos, model) for i in ids]
-end
 # ```@raw html
 # <video width="auto" controls autoplay loop>
 # <source src="../outbreak.mp4" type="video/mp4">
diff --git a/src/Agents.jl b/src/Agents.jl
index 211b512881..439260e904 100644
--- a/src/Agents.jl
+++ b/src/Agents.jl
@@ -44,7 +44,7 @@ include("deprecations.jl")
 # Update messages:
 using Scratch
 display_update = true
-version_number = "4.6"
+version_number = "5"
 update_name = "update_v$(version_number)"
 
 function __init__()
@@ -56,9 +56,26 @@ if display_update
             stdout,
             """
             \nUpdate message: Agents v$(version_number)
-            Please see the changelog online. Some key features:
+            Welcome to this new major version of Agents.jl!
+            Noteworthy changes:
 
-            * Agents.jl now uses [Graphs.jl](https://github.com/JuliaGraphs/Graphs.jl) instead of LightGraphs.jl
+            * LightGraphs.jl dependency has been replaced by Graphs.jl.
+              No change was done to `GraphSpace`, you only need to replace
+              `using LightGraphs` with `using Graphs`.
+            * The `OpenStreetMapSpace` now uses a new depedency, LightOSM.jl,
+              which is much more performant than the previous OpenStreetMapX.jl.
+              This meas that initializing a new space is slightly different, see
+              the docstring of `OpenStreetMapSpace` for more.
+            * Agents.jl + InteractiveDynamics.jl now support native plotting for
+              open street map spaces, which is integrated in all interactive apps as well!
+            * The majority of examples of the documentation have now moved to a new repository,
+              JuliaDyamics/AgentsExampleZoo.jl. From now on, all additional examples
+              will be hosted in that repo, to keep the main documentation lean.
+            * Functions for planning and moving along routes have had their names
+              unified across Pathfinding and OpenStreetMap modules. The names now are
+              `plan_route!` and `move_along_route!` and are accessible from the top
+              level scope.
+            * See the CHANGELOG.md or online docs for more!
             """;
             color = :light_magenta,
         )
diff --git a/src/deprecations.jl b/src/deprecations.jl
index 5dfc87a9d5..8f33391ed1 100644
--- a/src/deprecations.jl
+++ b/src/deprecations.jl
@@ -1 +1 @@
-# @deprecate OSM.random_route! OSM.plan_random_route!
\ No newline at end of file
+# Some deprecations exist in submodules Pathfinding, OSM
\ No newline at end of file
diff --git a/src/models/zombies.jl b/src/models/zombies.jl
index 1af7bc4772..01bbd9ed1f 100644
--- a/src/models/zombies.jl
+++ b/src/models/zombies.jl
@@ -27,7 +27,7 @@ function zombies(; seed = 1234)
         OSM.plan_random_route!(human, model; limit = 50) # try 50 times to find a random route
     end
     ## We'll add patient zero at a specific (latitude, longitude)
-    start = OSM.nearest_intersection((51.5328328, 9.9351811), model)
+    start = OSM.nearest_road((51.5328328, 9.9351811), model)
     finish = OSM.nearest_node((51.530876112711745, 9.945125635913511), model)
 
     speed = rand(model.rng) * 5.0 + 2.0 # Random speed from 2-7kmph
@@ -39,13 +39,13 @@ end
 
 function zombie_agent_step!(agent, model)
     ## Each agent will progress slightly along their route
-    move_along_route!(agent, model, agent.speed * model.dt)
+    distance_left = move_along_route!(agent, model, agent.speed * model.dt)
 
     if is_stationary(agent, model) && rand(model.rng) < 0.1
         ## When stationary, give the agent a 10% chance of going somewhere else
         OSM.plan_random_route!(agent, model; limit = 50)
         ## Start on new route
-        move_along_route!(agent, model, agent.speed * model.dt)
+        move_along_route!(agent, model, distance_left)
     end
 
     if agent.infected
diff --git a/src/spaces/openstreetmap.jl b/src/spaces/openstreetmap.jl
index 372caf3425..885da13a4b 100644
--- a/src/spaces/openstreetmap.jl
+++ b/src/spaces/openstreetmap.jl
@@ -87,7 +87,7 @@ end
 Current `pos`ition tuple is represented as
 `(first intersection index, second intersection index, distance travelled)`.
 The distance travelled is in the units of `weight_type`. This ensures that the map
-is a *continuous* kind of space, as an agent can truly be at any possible point on 
+is a *continuous* kind of space, as an agent can truly be at any possible point on
 an existing road.
 
 Use [`OSMAgent`](@ref) for convenience.
@@ -159,13 +159,14 @@ function random_road_position(model::ABM{<:OpenStreetMapSpace})
 end
 
 """
-    OSM.plan_random_route!(agent, model::ABM{<:OpenStreetMapSpace}; kwargs...)
+    OSM.plan_random_route!(agent, model::ABM{<:OpenStreetMapSpace}; kwargs...) → success
 
 Plan a new random route for the agent, by selecting a random destination and
 planning a route from the agent's current position. Overwrite any existing route.
 
 The keyword `limit = 10` specifies the limit on the number of attempts at planning
-a random route. Returns `true` if a route was successfully planned, `false` otherwise.
+a random route, as no connection may be possible given the random start and end.
+Return `true` if a route was successfully planned, `false` otherwise.
 All other keywords are passed to [`plan_route!`](@ref)
 """
 function plan_random_route!(
@@ -302,6 +303,8 @@ function Agents.plan_route!(
     route = Int[]
 
     try
+        # TODO: Try-catch blocks are bad for performance. This has to be changed
+        # to something else in the future.
         route = shortest_path(
             model.space.map,
             model.space.map.index_to_node[start_node],
@@ -524,7 +527,7 @@ end
 lonlat(agent::A, model::ABM{<:OpenStreetMapSpace,A}) where {A<:AbstractAgent} =
     lonlat(agent.pos, model)
 
-latlon(pos::Int, model::ABM{<:OpenStreetMapSpace}) = 
+latlon(pos::Int, model::ABM{<:OpenStreetMapSpace}) =
     Tuple(model.space.map.node_coordinates[pos])
 latlon(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}) =
     reverse(lonlat(pos, model))
@@ -539,7 +542,8 @@ Quicker, but less precise than [`OSM.nearest_road`](@ref).
 """
 function nearest_node(ll::Tuple{Float64,Float64}, model::ABM{<:OpenStreetMapSpace})
     ll = reverse(ll)
-    nearest_node_id = LightOSM.nearest_node(model.space.map, [GeoLocation(ll..., 0.0)])[1][1][1]
+    nearest_node_id = LightOSM.nearest_node(model.space.map,
+        [GeoLocation(ll..., 0.0)])[1][1][1]
     vert = Int(model.space.map.node_to_index[nearest_node_id])
     return (vert, vert, 0.0)
 end
@@ -547,8 +551,8 @@ end
 """
     OSM.nearest_road(lonlat::Tuple{Float64,Float64}, model::ABM{<:OpenStreetMapSpace})
 
-Return a location on a road nearest to **(longitude, latitude)**. Significantly slower, but more
-precise than [`OSM.nearest_node`](@ref).
+Return a location on a road nearest to **(longitude, latitude)**.
+Significantly slower, but more precise than [`OSM.nearest_node`](@ref).
 """
 function nearest_road(ll::Tuple{Float64,Float64}, model::ABM{<:OpenStreetMapSpace})
     ll = reverse(ll)
@@ -556,12 +560,14 @@ function nearest_road(ll::Tuple{Float64,Float64}, model::ABM{<:OpenStreetMapSpac
     best = (-1, -1, -1.0)
     pt = LightOSM.to_cartesian(GeoLocation(ll..., 0.0))
     for e in edges(model.space.map.graph)
-        s = LightOSM.to_cartesian(GeoLocation(model.space.map.node_coordinates[src(e)]..., 0.0))
-        d = LightOSM.to_cartesian(GeoLocation(model.space.map.node_coordinates[dst(e)]..., 0.0))
+        s = LightOSM.to_cartesian(GeoLocation(
+                model.space.map.node_coordinates[src(e)]..., 0.0))
+        d = LightOSM.to_cartesian(GeoLocation(
+                model.space.map.node_coordinates[dst(e)]..., 0.0))
         road_vec = d .- s
 
-        # closest point on line segment requires checking if perpendicular from point lies on line
-        # segment. If not, use the closest end of the line segment
+        # closest point on line segment requires checking if perpendicular
+        # from point lies on line segment. If not, use the closest end of the line segment
         if dot(pt .- s, road_vec) < 0.0
             int_pt = s
         elseif dot(pt .- d, road_vec) > 0.0
@@ -574,7 +580,8 @@ function nearest_road(ll::Tuple{Float64,Float64}, model::ABM{<:OpenStreetMapSpac
 
         if sq_dist < best_sq_dist
             best_sq_dist = sq_dist
-            rd_dist = norm(int_pt .- s) / norm(road_vec) * road_length(Int(src(e)), Int(dst(e)), model)
+            rd_dist = norm(int_pt .- s) / norm(road_vec) *
+                road_length(Int(src(e)), Int(dst(e)), model)
 
             best = (
                 Int(src(e)),
@@ -615,12 +622,13 @@ end
 
 Return `GeoLocation` corresponding to node `pos`
 """
-get_geoloc(pos::Int, model::ABM{<:OpenStreetMapSpace}) = GeoLocation(model.space.map.node_coordinates[pos]..., 0.0)
+get_geoloc(pos::Int, model::ABM{<:OpenStreetMapSpace}) =
+    GeoLocation(model.space.map.node_coordinates[pos]..., 0.0)
 
 """
     OSM.get_reverse_direction(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace})
 
-Returns the same position, but with `pos[1]` and `pos[2]` swapped and `pos[3]` updated accordingly
+Return the same position, but with `pos[1]` and `pos[2]` swapped and `pos[3]` updated.
 """
 get_reverse_direction(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}) =
     (pos[2], pos[1], road_length(pos, model) - pos[3])
@@ -628,7 +636,6 @@ get_reverse_direction(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpa
 #######################################################################################
 # Agents.jl space API
 #######################################################################################
-
 function Agents.random_position(model::ABM{<:OpenStreetMapSpace})
     vert = Int(rand(model.rng, 1:Agents.nv(model)))
     return (vert, vert, 0.0)
@@ -667,19 +674,20 @@ function Agents.move_agent!(
 end
 
 """
-    move_along_route!(agent, model::ABM{<:OpenStreetMapSpace}, distance::Real) -> remaining
+    move_along_route!(agent, model::ABM{<:OpenStreetMapSpace}, distance::Real) → remaining
 
 Move an agent by `distance` along its planned route. Units of distance are as specified
 by the underlying graph's weight_type. If the provided `distance` is greater than the
-distance to the end of the route, return the remaining distance. Otherwise, return 0.
+distance to the end of the route, return the remaining distance. Otherwise, return `0`.
+`0` is also returned if `is_stationary(agent, model)`.
 """
 function Agents.move_along_route!(
     agent::A,
     model::ABM{<:OpenStreetMapSpace,A},
     distance::Real,
 ) where {A<:AbstractAgent}
-    if is_stationary(agent, model)
-        return nothing
+    if is_stationary(agent, model) || distance == 0
+        return 0
     end
 
     # branching here corresponds to nesting of the following cases:
@@ -756,7 +764,8 @@ function Agents.move_along_route!(
             distance -= dist_left   # leftover distance
             node_a = pop!(osmpath.route)    # remove the node we just reached
             if isempty(osmpath.route)
-                # this was the last node, so either we reached the end or dest is on an outgoing road
+                # this was the last node, so either we reached the end
+                # or dest is on an outgoing road
                 if osmpath.dest[1] == osmpath.dest[2]   # we reached the end
                     if osmpath.has_to_return    # need to return from here
                         # empty return route, so reverse along same edge
@@ -879,7 +888,7 @@ function Agents.nearby_ids(
             for id in reverse_ids_on_road(pos[1], pos[2], model)
                 dist_2 < model[id].pos[3] < dist_2 + distance && push!(nearby, id)
             end
-        else    # neither node is within `distance` of `pos`, so simply filter IDs on this road
+        else # neither node is within `distance` of `pos`, so simply filter IDs on this road
             for id in forward_ids_on_road(pos[1], pos[2], model)
                 abs(model[id].pos[3] - dist_1) <= distance && push!(nearby, id)
             end
@@ -889,11 +898,13 @@ function Agents.nearby_ids(
         end
     end
 
-    # NOTE: During BFS, each node is only explored once. From each node, every outgoing and incoming edge is
-    # considered and the node on the other end is added to the queue if it is close enough. The edge is explored
-    # for IDs by the node with the lower index (to prevent the same edge from being explored twice).
-    # If the node on the other end can't be reached, then the current node explores however far it can on
-    # this road. If the other node is reached through another path, it takes this into account and only explores
+    # NOTE: During BFS, each node is only explored once.
+    # From each node, every outgoing and incoming edge is considered and the node on the
+    # other end is added to the queue if it is close enough. The edge is explored
+    # for IDs by the node with the lower index (to prevent the same edge from being
+    # explored twice). If the node on the other end can't be reached, then the current
+    # node explores however far it can on this road. If the other node is reached through
+    # another path, it takes this into account and only explores
     # the unexplored part of this edge.
     while !isempty(queue)
         node = dequeue!(queue)
@@ -975,6 +986,16 @@ function Agents.nearby_positions(
     Int.(neighborfn(model.space.map.graph, position))
 end
 
+# Deprecations
+function latlon(args...)
+    @warn "`latlon` is deprecated in favor of `lonlat`."
+    return reverse(lonlat(args...))
+end
+
+@deprecate random_route! plan_random_route!
+@deprecate intersection nearest_node
+@deprecate road nearest_road
+
 end # module OSM
 
 const OpenStreetMapSpace = OSM.OpenStreetMapSpace
diff --git a/src/submodules/pathfinding/Pathfinding.jl b/src/submodules/pathfinding/Pathfinding.jl
index cf0f3e08a7..412f8fd445 100644
--- a/src/submodules/pathfinding/Pathfinding.jl
+++ b/src/submodules/pathfinding/Pathfinding.jl
@@ -43,4 +43,8 @@ export CostMetric,
     nearby_walkable,
     random_walkable
 
-end
+# Deprecations
+@deprecate set_target! plan_route!
+@deprecate set_best_target! plan_best_route!
+
+end # module
diff --git a/src/visualization/plot-recipes.jl b/src/visualization/plot-recipes.jl
deleted file mode 100644
index e7b2f6b878..0000000000
--- a/src/visualization/plot-recipes.jl
+++ /dev/null
@@ -1,139 +0,0 @@
-using RecipesBase
-using GraphRecipes
-
-export plotabm, plotabm!, abm_plot_on_graph, abm_plot_on_graph!
-
-mutable struct PlotABM{AbstractSpace}
-    args::Any
-end
-
-"""
-    plotabm(model::ABM{<: ContinuousSpace}; ac, as, am, kwargs...)
-    plotabm(model::ABM{<: DiscreteSpace}; ac, as, am, kwargs...)
-
-Plot the `model` as a `scatter`-plot, by configuring the agent color, size and marker (shape)
-via the keywords `ac, as, am`.
-These keywords can be constants, or they can be functions, each accepting an agent
-and outputting a valid value for color/size/marker.
-
-The keyword `scheduler = model.scheduler` decides the plotting order of agents
-(which matters only if there is overlap).
-
-The keyword `offset` is a function with argument `offest(a::Agent)`.
-It targets scenarios where multiple agents existin within
-a grid cell as it adds an offset (same type as `agent.pos`) to the plotted agent position.
-
-All other keywords are propagated into `Plots.scatter` and the plot is returned.
-
-    plotabm(model::ABM{<: GraphSpace}; ac, as, am, kwargs...)
-This function is the same as `plotabm` for `ContinuousSpace`, but here the three key
-functions `ac, as, am` do not get an agent as an input but a vector of agents at
-each node of the graph. Their output is the same.
-
-Here `as` defaults to `length`. Internally, the `graphplot` recipe is used, and
-all other `kwargs...` are propagated there.
-"""
-plotabm(args...; kw...) = RecipesBase.plot(PlotABM{typeof(args[1].space)}(args); kw...)
-
-"""
-    plotabm!(model)
-    plotabm!(plt, model)
-
-Functionally the same as [`plotabm`](@ref), however this method appends to the active
-plot, or one identified as `plt`.
-"""
-plotabm!(args...; kw...) = RecipesBase.plot!(PlotABM{typeof(args[1].space)}(args); kw...)
-plotabm!(plt::RecipesBase.AbstractPlot, args...; kw...) =
-    RecipesBase.plot!(plt, PlotABM{typeof(args[1].space)}(args); kw...)
-
-@recipe function f(
-    h::PlotABM{<:Union{GridSpace,ContinuousSpace}};
-    scheduler = nothing,
-    offset = nothing,
-    ac = "#765db4",
-    as = 10,
-    am = :circle,
-    warn = true,
-)
-    if length(h.args) != 1 || !(typeof(h.args[1]) <: ABM)
-        error("plotabm should be given a model::ABM.  Got: $(typeof(h.args))")
-    end
-    warn && (@warn "Plots.jl recipes have been superseded by InteractiveDynamics.jl")
-
-    model = h.args[1]
-    if scheduler === nothing
-        scheduler = model.scheduler
-    end
-
-    ids = scheduler(model)
-    colors = typeof(ac) <: Function ? [ac(model[i]) for i in ids] : ac
-    sizes = typeof(as) <: Function ? [as(model[i]) for i in ids] : as
-    markers = typeof(am) <: Function ? [am(model[i]) for i in ids] : am
-
-    if offset === nothing
-        pos = [model[i].pos for i in ids]
-    else
-        pos = [model[i].pos .+ offset(model[i]) for i in ids]
-    end
-    x := first.(pos)
-    y := last.(pos)
-
-    seriestype := :scatter
-    markercolor := colors
-    markersize := sizes
-    markershape := markers
-    legend --> false
-    markerstrokewidth --> 0.5
-    markerstrokecolor --> :black
-    ()
-end
-
-@recipe function f(
-    h::PlotABM{<:GraphSpace};
-    ac = x -> "#765db4",
-    as = length,
-    am = x -> :circle,
-    warn = true,
-)
-    if length(h.args) != 1 || !(typeof(h.args[1]) <: ABM)
-        error("plotabm should be given a model::ABM.  Got: $(typeof(h.args))")
-    end
-    warn && (@warn "Plots.jl recipes have been superseded by InteractiveDynamics.jl")
-
-    model = h.args[1]
-    N = nodes(model)
-    ncolor = Vector(undef, length(N))
-    weights = zeros(length(N))
-    markers = Vector(undef, length(N))
-    for (i, n) in enumerate(N)
-        a = get_node_agents(n, model)
-        ncolor[i] = ac(a)
-        weights[i] = as(a)
-        markers[i] = am(a)
-    end
-
-    node_weights := weights
-    nodeshape := markers
-    nodecolor := ncolor
-    seriescolor --> :black
-    markerstrokecolor --> :black
-    markerstrokewidth --> 1.5
-    model.space.graph
-end
-
-"""
-    abm_plot_on_graph(model::ABM{<: GraphSpace}; ac, as, am, kwargs...)
-This function plots an ABM with a [`GraphSpace`](@ref). It functions similarly
-with [`abm_plot`], but is based on Plots.jl (specifically GraphRecipes.jl).
-
-The three key functions `ac, as, am` do not get an agent as an input but a vector of
-agents at each node of the graph. Their output is the same: the color, size, and marker
-type of the node.
-
-Here `as` defaults to `length`. Internally, the `graphplot` recipe is used, and
-all other `kwargs...` are propagated there.
-"""
-abm_plot_on_graph(args...; kw...) = RecipesBase.plot(PlotABM{typeof(args[1].space)}(args); kw...)
-abm_plot_on_graph!(args...; kw...) = RecipesBase.plot!(PlotABM{typeof(args[1].space)}(args); kw...)
-abm_plot_on_graph!(plt::RecipesBase.AbstractPlot, args...; kw...) =
-    RecipesBase.plot!(plt, PlotABM{typeof(args[1].space)}(args); kw...)
diff --git a/test/test.jld2 b/test/test.jld2
deleted file mode 100644
index 783a533ad7..0000000000
Binary files a/test/test.jld2 and /dev/null differ