charliejhadley

Round 2! Beyond Plotly, Interactive dataviz with R

Mon, 26 Jan 2026 00:00:00 GMT

Our “Beyond Plotly: Interactive Dataviz with R” workshop announcement was so popular we signed up 119 people in the first 5 days. So we’ve added a second session on Monday 26th January.

Plotly abandoned r in September 2025. Start your new year expanding your vision of what’s possible with interactive data visualisation in R through {htmlwidgets}.

In this interactive, live code driven workshop we’ll explore how it’s not {plotly} that’s magic - it’s htmlwidgets. We’ll cover so many things including:

Building next-level interactive {ggplot2} charts with {ggiraph} instead of ggplotly()
Effectively choosing your tools for interactive data visualisation of charts, maps, tables and more
Unlocking reliable integration of your Shiny apps with the whole universe of htmlwidgets
How you could build your own {htmlwidgets} and contribute to existing packages.
Bring your questions and imagination to this workshop - it’ll be fun! We’ll take some questions during the session to drive the live code and will make sure there’s plenty of time for questions at the end.

Beyond Plotly: interactive dataviz with R

Wed, 21 Jan 2026 00:00:00 GMT

Plotly abandoned r in September 2025. Start your new year expanding your vision of what’s possible with interactive data visualisation in R through {htmlwidgets}.

In this interactive, live code driven workshop we’ll explore how it’s not {plotly} that’s magic - it’s htmlwidgets. We’ll cover so many things including:

Building next-level interactive {ggplot2} charts with {ggiraph} instead of ggplotly()
Effectively choosing your tools for interactive data visualisation of charts, maps, tables and more
Unlocking reliable integration of your Shiny apps with the whole universe of htmlwidgets
How you could build your own {htmlwidgets} and contribute to existing packages.
Bring your questions and imagination to this workshop - it’ll be fun! We’ll take some questions during the session to drive the live code and will make sure there’s plenty of time for questions at the end.

Plotly abandoned R in 2025. Start 2026 thinking if it really is your best choice.

Charlotte Jane Hadley — Mon, 05 Jan 2026 00:00:00 GMT

*They also abandoned their MATLAB, Julia and F# libraries.

We have a note for you if plotly is mission critical for you

It’s true. In September 2025 the Plotly company announced they are abandoning their R* documentation and packages. Plotly didn’t need to do this.

They made the announcement one day after announcing their “Rise of Vibe Analytics” event. It is clear that Plotly is not a data visualisation company with a broad commitment to Open Source. They’re a vibe analytics and enterprise BI outfit.

We want you to spend 15minutes at the start of 2026 thinking about if Plotly really is your best (and only) choice in R, Quarto and Shiny.

{plotly} isn’t magic, it’s a {htmlwidgets} package

Do you know how {plotly} is able to create interactive dataviz in R, Quarto and Shiny? It’s 100% down to the magic of {htmlwidgets} which enables such rich interactive dataviz with R.

You might not believe the diversity of what’s possible - check out these examples:

The {leaflet} package is the best choice for creating interactive maps.

Code

{ggplot2}’s two level aesthetics: dataviz or geom-specific

Charlotte Jane Hadley — Fri, 02 Jan 2026 00:00:00 GMT

In {ggplot2} it’s aes() that does all the heavy lifting.

But there are two levels of aesthetics. And a few ways of specifying them. If you don’t really feel confident with aes() start reading what does aes() actually do?.

Dataviz-level aesthetics
Geom-specific aesthetics.

The differences and nuances between these are unfortunately often misunderstood and lead to confusion. So let’s get into them.

Dataviz-level aesthetics.

This is the type of aesthetic used in most data visualisations built with {ggplot2}, but you’ll see them written in two slightly different ways:

library("tidyverse")
library("fivethirtyeight")

# Traditional
bechdel |>
  ggplot(aes(x = budget_2013, y = domgross_2013))

library("tidyverse")
library("fivethirtyeight")

# Explicit
bechdel |>
  ggplot() +
  aes(x = budget_2013, y = domgross_2013)

Both of these will produce the exact same chart and there are no functional differences between them, but we’re huge fans of the “explicit dataviz-level aesthetics” and recommend that you use it for three reasons:

Fewer nested brackets makes code easier to read!
Commenting out aesthetics and messing about with them is much easier than in the “traditional” format
It is extremely flexible when you get into advanced dataviz with {ggplot2} in two important use cases

Add conditional aesthetics when building functions
Programmatically map over base plots with alternating dataviz-level aesthetics

Build all your charts like this instead of swapping between traditional and explicit for consistency. It will also make scope creep much easier to deal with!

Great. But what does aes() actually do?

What does aes() actually do?

ggplot2 uses aes() to turn your data into dataviz. It does that by creating aesthetic mappings between your data and the coordinate systems of your chart, let’s take a proper look at that chart:

library("tidyverse")
library("fivethirtyeight")

bechdel |>
  ggplot() +
  aes(x = budget_2013, y = domgross_2013)

We have axes! Where did they come from? Well, {ggplot2} sends the aesthetic mappings over to the {scales} package which builds the axes that we see. In fact, {scales} is the unsung hero of {ggplot2} which simply wouldn’t work without it. It’s such an integral part of many R tools that you’ll find {scales} in the R-lib Infrastructure collection of packages, instead of the {tidyverse}.

In our R Dataviz Bootcamp we go deep into how to take control of these scales, but for now let’s move on to geom-specific aesthetics.

Geom-level aesthetics

You need to use geom-level aesthetics in one of three circumstances:

A geom needs additional aesthetics not provided at the dataviz-level
A geom is being given different aesthetics to the dataviz-level aesthetics
A geom is being given an entirely different dataset and new aesthetic mappings are required.

Let’s go through these in turn.

Some geoms need additional aesthetics

Some geoms have specific aesthetics they need to work. A nice example for our chart is geom_vline() which requires xintercept. It would be confusing if that appeared in the dataviz-level aesthetics, and in some cases could break other geoms.

bechdel |>
  ggplot() +
  aes(x = budget_2013, y = domgross_2013) +
  geom_point() +
  geom_vline(aes(xintercept = mean(budget_2013, na.rm = TRUE)))

Be careful with the more fiddly geoms as there are big differences between x, xend and xmax. Refer to the documentation for the specific geoms you’re working with.

Geom is given different aesthetics

Something you could do is visualise the mean() and median() values like this:

bechdel |>
  ggplot() +
  aes(x = budget_2013, y = domgross_2013) +
  geom_point() +
  geom_point(
    aes(
      x = mean(budget_2013, na.rm = TRUE),
      y = mean(domgross_2013, na.rm = TRUE)
    ),
    colour = "#1E8F91",
    size = 10
  ) +
  geom_point(
    aes(
      x = median(budget_2013, na.rm = TRUE),
      y = median(domgross_2013, na.rm = TRUE)
    ),
    colour = "#AA3D4F",
    size = 10
  )

Now. This is not an easy chart to work with. If we wanted to add legends to this it would be chaos. Oh, and {ggplot2} gives us this warning:

1: In geom_point(aes(x = mean(budget_2013, na.rm = TRUE), y = mean(domgross_2013, All aesthetics have length 1, but the data has 1794 rows. ℹ Please consider using annotate() or provide this layer with data containing a single row.

But, the thing is that annotate() isn’t your friend here as you can’t create aesthetic mappings with it.

The best solution to this problem is giving a geom an entirely different dataset

Geom is given an entirely different dataset

This is where {ggplot2} gets really powerful because we can combine multiple datasets into one chart and take advantage of shared {scales} within the chart.

To elegantly show that let’s use a little bit of {tidyverse} jiggery pockery to make a nice tidy dataset with the summary statistics we showed before:

Code

Curves and stones

Charlotte Jane Hadley — Mon, 29 Dec 2025 00:00:00 GMT

There aren’t many simple geometric objects from cinema that I remember more clearly (and often) than the elemental stones from the Fifth Element movie. I’m trying to flex my skills in procedural art with {ggplot2} and stumbled across this “Waves Patch” piece from Megan Harris’ incredible “rtristy gallery” which inspired me to try and craft something. Let’s give it a go.

Elemental stones from the Fifth Element

“Wave Patch” procedural art by Meghan Harris

Sine curves

Meghan visualises sine curves using by sampling along a sin() curve using seq() and then visualises that curve with geom_path(). Here’s a reproducition of that at it’s simplest:

Code

Highcharts, do.call and c(list())

Charlotte Jane Hadley — Wed, 10 Dec 2025 00:00:00 GMT

{ "@context": "https://schema.org", "@type": "BlogPosting", "headline": "Highcharts, do.call and c(list())", "description": "Getting around Error: All arguments must be named list, and why does do.call() want c(list(), list(…)) with htmlwidgets?", "image": "do-call.png","keywords": ["R", "highcharter", "meta-programming", "non-standard-evaluation"], "datePublished": "December 10, 2025T09:00:00+00:00", "author": { "@type": "Person", "name": "Charlotte Jane Hadley", "url": "https://www.linkedin.com/in/charliejhadley/" }, "publisher": { "@type": "Organization", "name": "Visible Data" }, "mainEntityOfPage": "www.visibledata.io" }

I love the {highcharter} package. I think it makes some of the most beautiful, engaging and accessible data visualisations amongst all the {htmlwidgets} packages that I use. It’s very customisable! But if you’re like my clients at SafeLives when you try do advanced things with the package you might get stuck on this problem:

Error: All arguments must be named list

This is just one example of where we need to introduce do.call() to provide a list of arguments to a function that get executed as if the function was called directly with those arguments.

Oooft. That gets into meta-programming and non-standard evaluation. Which gets slightly complicated by using htmlwidgets objects.

A {highcharter} motivating example

Let’s make an example chart showing how many respondents fall in each marital status from the gss_cat dataset:

Code

Your year in ggplot2 with {ggplot2wrapped} 2025!

Mon, 01 Dec 2025 00:00:00 GMT

We’re so excited to announce the launch of our new R package {ggplot2wrapped} which offers you a “Spotify Wrapped” like experience for your year in {ggplot2}! There’s a lot to say about the package but the easiest way to understand it is to checkout an example ggplot2wrapped report which is summarised in the GIF below.

The whole package works thanks to the {astgrep} package which allows us to build Abstract Syntax Trees (ASTs) from .R, .qmd and .Rmd files and then extract out geom_point() etc calls. You might mistakingly think you could just read a script file with readLines() and use regex.

Well, let’s make a mock script file that contains what we do want (a geom_point call) and other things we very much don’t want.

# We do want
ggplot() +
  geom_point(aes(x = thing), size = 2)

# We don't want
g_title <- "I love geom_point"

# We don't want
geom_state_secret() <- function(){}

REGEX will not help you here. You want to build Abstract Syntax Trees (ASTs) which I achieved using the {astgrepr} package because it makes it very easy to extract arguments from the function call which we can then analyse.

code_file |>
  tree_new() |>
  tree_root() |> 
  node_find_all(ast_rule(
    id = "geom_point",
    pattern = "geom_point($$$A)")
  ) |> 
  node_text_all()

# $geom_point
# $geom_point$node_1
# [1] "geom_point(aes(x = thing), size = 2)"

Making your own {ggplot2wrapped}

Great! So how would I use the actual package? Well, it’s easy. This will find file info for all the R code files in the filepaths you provide:

library("tidyverse")
library("ggplot2wrapped")

code_files <- get_code_file_info(c("~/Github/", "~/coding/r-projects-scrapbook/"), file_type = c(".qmd", ".R", ".Rmd"))

Next the add_geom_usuage_to_files() function does the ASTs clever stuff and emits a note that the object contains potentially sensitive information because your actual function calls are included.

target_year <- 2024
code_files_from_target_year <- code_files |>
  slice(1:5)

data_geoms_usage_target_year <- code_files_from_target_year |> 
  add_geom_usage_to_files()

data_geoms_usage_target_year
#> ℹ Remember this output object contains your actual geom calls therefore it
#> should be considered sensitive. The column with this sensitive information is
#> called `function_call`.
#> # A tibble: 15 × 12
#>    file_path              file_extension modified_time       created_time       
#>                                                           
#>  1 /Users/charliejhadley… R              2025-11-30 17:36:01 2025-11-30 17:36:01
#>  2 /Users/charliejhadley… R              2025-11-30 17:36:01 2025-11-30 17:36:01
#>  3 /Users/charliejhadley… R              2025-11-30 17:36:01 2025-11-30 17:36:01
#> # ℹ 8 more variables: access_time , geom_name , has_aes ,
#> #   function_call , length_of_call , n_args_in_call ,
#> #   n_times_used , package_name

Oh, wait. Which geoms does this look for? Well, by default the data_geoms argument takes the ggplot2wrapped::data_geoms object which includes all of the geoms in {ggplot2}, {ggrepel} and {ggtext} as of 2025-12-01. You’re very welcome to add additional geoms to your analysis.

Next to generate your personalised scrollytelling report you just need to run this code:

data_geoms_usage_target_year %>% 
  ggplot_wrapped_2025(data_geoms, report_year = target_year)

Visualisations included

I turned this package around within a week and an extra weekend. Out of the 10 visualisations I added into the scrollytelling report I managed to turn 6 of them into nice re-usable functions before my self-imposed deadline.

UpSet charts

I’m most proud of the UpSet charts that are produced with the amazing {upsetjs} package. You might not have heard of the UpSet chart before! That’s unsurprising as they’re quite rare and were only invented in 2012. Here’s an example:

data_example_geom_usage |> 
  make_geom_interactive_upset_chart(height = 600)

Now, quite rightly (I think) the authors of the visualisation ask for the original paper to be cited whenever they’re used.

Alexander Lex, Nils Gehlenborg, Hendrik Strobelt, Romain Vuillemot, Hanspeter Pfister. UpSet: Visualization of Intersecting Sets IEEE Transactions on Visualization and Computer Graphics (InfoVis), 20(12): 1983–1992, doi:10.1109/TVCG.2014.2346248, 2014.

Future plans

It was a real rush and lots of fun building this from a silly idea I had cycling home into a package that builds a programmatically generated scrollytelling report with {closeread} with a nice narrative. This is far from the end of {ggplot2wrapped}. I’ll be writing up a few blogposts from things learned along the way and in 2026 you can expect a much improved package with new things.

Oh! The wonderful folks who designed the {ggplot2} hex sticker made it CC0 licensed so I could add a bow to it for my package’s own hex sticker.

Announcing our launch workshop!

Mon, 03 Nov 2025 00:00:00 GMT

We’re very excited to finally be launching GCPDS in November 2025!

There’s lots we haven’t exactly finished setting up yet. But we are very excited to invite you to the first of many data visualisation workshops

Storytelling shouldn’t be the only thing you do with data visualisation

Wednesday 19th November 2025
1:00pm - 2:30pm UK (UTC) time
Zoom (see below for details)

Storytelling is a significant component of the role data visualisation plays in being data-driven, but it absolutely can’t be the only thing you do with it.

You need dataviz for every point in your data journey, decision making and communication. All the way from EDA to modelling, through to reporting and engagement.

You can’t use the same charts or tell exactly the same story in all mediums.

We run workshops as fun, interactive sessions where we’ll do live data/code work and build things from your questions and input.

We do not run second-screen, camera-off and eat lunch webinars. Come along to learn, have fun and leave equipped with new knowledge and skills.

To celebrate our launch in November 2025 we are hosting our first workshop with lower pricing than we would usually set.

Meet your coach

Charlotte Jane Hadley
She/Her
charliejhadley
0000-0002-3039-6849

Hey - I’m Charlie! 🙋‍♀️

I’ve been coaching, training and working hands-on in data visualisation and storytelling since 2012.

I’m a proudly certified and commercially successful data coach, and I’ve built the data-focused train the trainer program for the multiple award winning Data & AI Academy at Admiral.

Nothing is more important to me more than meeting my learners and customers where you are. It doesn’t matter what your tech, data or visualisation fluency is. I love finding what matters to you and building from there.

2012
2015
2017
2022
2025

Read more about Charlie’s work in her full profile.

Fancy getting in touch? Say hello@visibledata.io.