useR! 2026

6 Jul 2026, 08:00 → 9 Jul 2026, 19:00 Europe/Warsaw

Call for proposals has ended. 

Welcome to the event management platform for useR!2026!

Here you can register for conference participation and submit abstracts.

Please check out the bottom of the page to find the abstract submission system. 

For more information, check out our website.

Conference Dates

Jul 6, 2026

Pre-conference tutorial day

Jul 7, 2026

Conference starts

Jul 8, 2026

Conference dinner

Jul 9, 2026

Conference ends

 

Registration Dates

Feb 2, 2026

Submission of tutorials and talks open

Mar 8, 2026

Submission of tutorials and talks close 
Update: Call for proposals extended until Mar 14

Mar 9, 2026

Registration starts

Mar 27, 2026

Notification of acceptance of tutorials and talks

Apr 20, 2026

Early registration ends

Jun 12, 2026

Registration ends

 

We are looking forward to seeing you this summer!

 

Monday 6 July

08:00 Registration open

Tutorials: Morning Block

1 Convex Optimization in R Using CVXR

Convex optimization is fundamental to modern statistics and machine learning, underpinning methods from least squares and ridge regression to support vector machines (SVMs) and portfolio optimization. While Python users have long enjoyed state-of-the-art convex optimization through CVXPY, R users now have access to the same capabilities through CVXR 1.8.x---a complete rewrite using R's S7 class system that brings full parity with CVXPY 1.8.1. Participants will work through a rich set of examples and be introduced to powerful new features. We show how to use different solvers, both open source (authored on CRAN by us) and commercial grade (MOSEK, Gurobi, CPLEX). The tutorial concludes with an open problem-solving session where attendees will be invited to bring their own problems to formulate in CVXR and solve them.

Introduction: (20min): Convex problems in statistics and ML, Basic examples from regression, nonlinear least squares.

Disciplined Convex Programming (20 min): DCP rules, automatic convexity verification. CVXR's variables, parameters, constraints, objectives, documentation

Examples I (40min): Elastic-net, lasso, ridge, Huber, logistic and quantile regression. Sparse Inverse Covariance estimation.

Examples II: (40min) Portfolio optimization, log-concanve density estimation, survey calibration.
Log-concave density estimation.

Efficiency: (25min) Disciplined Parameterized Programming for efficient parameter sweeps with compilation caching, visualization, debugging

Misc (20min): Mixed-integer programming, solver choices, open source and commercial.

Open Problem-Solving Session + Q&A (15 min): Attendees bring and solve their own optimization problems with instructor guidance.

Speakers: Ms Anqi Fu (Memorial Sloan Kettering), Balasubramanian Narasimhan (Stanford University)

Convex Optimization in R using CVXR

2 From Collecting Log-data to Analyzing Process Indicators with logLime R Package

This workshop introduces participants to the workflow of processing, analyzing and visualizing log-data describing respondent interactions with web survey interface collected from the open and popular LimeSurvey survey platform, using the logLime R package (along with other packages: dplyr, ggplot2, ggdensity and gganimate). While discussing this process, participants will discover different types of recorded events and learn how they are related to respondents’ actions. Moreover, we will explore different ways in which log-data can be aggregated to obtain datasets and indicators describing either sequences of events or states at the predefined time points. We will discuss possibilities to use the logLime package with data collected from other sources and prospects for the future development of the package.

Outline:
1. Workflow for survey log-data collection, processing and analyzis (20 min.)
2. Importing log-data into R (10 min.)
3. Diagnosing problems and performing cleaning of the log-data (20 min.)
4. Computing process indicators including: 1) response editing, 2) hovering indices, 3) indicators based on item-level response times, 4) cursor moves indices, 5) survey navigation indices. (25 min.)
5. Coffee break (15 min)
6. Visualizing respondent behaviors with heatmaps, using packages ggplot2 and ggdensity (30 min.)
7. Drawing cursor traces and clicks, using package ggplot2 (20 min.)
8. Animating cursor traces and clicks, using packages ggplot2 and gganimate (10 mins.)
9. Preparing data for analysis using other software, including LogFSM, ProcData or mousetrap R packages (10 min.)
10. Prospects for adaptation to other survey platforms (5 min.)
11. Q&A (15 min.)

Speaker: Dr Tomasz Żółtak (Institute of Philosophy and Sociology, Polish Academy of Sciences)

UseR!26-workshop-logdata.zip

Presentations

• 1-log-data-paradata.pdf
• 2-LogLime.pdf
• 3-mouse-moves-in-uncontrolled-environment.pdf

3 Geocomputation with R

R has become one of the most widely used languages for geographic data science. Its strength lies in a well-established ecosystem of several hundred spatial packages that support geographic data handling, analysis, and visualization, while integrating seamlessly with R’s wider tools for data processing and statistical analysis. R's flexibility and statistical capabilities make it attractive for researchers and practitioners working with geographic data across disciplines.

This hands-on tutorial introduces R's geospatial capabilities, building on the second edition of the book Geocomputation with R (https://r.geocompx.org/) by the tutorial instructors. We cover three core topics that provide a solid foundation for working with geographic data in R:

• Vector data with the sf package, implementing the simple features standard for representing points, lines, and polygons.
• Raster data with the terra package for gridded data such as remote sensing imagery and digital elevation models.
• Spatial data visualization using the tmap package for creating static and interactive maps.

In addition, time permitting, we include an additional applied topic (e.g., cloud-native geospatial workflows or Python interoperability).

Participants will learn to import, manipulate, and visualize geographic data through a mixture of presentations, live coding demonstrations, and interactive exercises. By the end of the tutorial, participants will have a practical understanding of how to work with spatial data in R and will be equipped with resources to continue learning and applying geocomputation techniques in their own work.

Speakers: Prof. Jakub Nowosad (Adam Mickiewicz University), Dr Jannes Muenchow (cynkra GmbH)

Workshop materials

4 Introduction to spatial data science

Brief biography

Krzysztof Dyba is a senior lecturer at Adam Mickiewicz University in Poznan specializing in spatial data science and remote sensing. His teaching experience includes conducting four international workshops on R applications for satellite data at the OpenGeoHub Summer School, as well as leading an external course on “Advanced Spatial Analysis” at Maria Curie-Sklodowska University in Lublin. He is actively involved in the development of open-source software for spatial data analysis in R (#rspatial) and is a co-maintainer of the CRAN Spatial Task View.

Broad topic that it covers

Concept of spatial data, Raster data processing, Vector data processing, Spatial data visualization

Proposed maximum number of participants: 50

Time slot:

• morning (8:30-12:00)
• afternoon (13:00-16:30)

Abstract

Spatial data has become an integral part of research and decision-making across a wide range of disciplines, including ecology, sociology, public health, economics, and many others. What makes spatial data unique compared to conventional tabular data is its direct link to a location on the Earth's surface, enabling the analysis and visualization of data within a geographical context. Driven by an extensive ecosystem and strong community support, R stands as one of the leading programming languages for spatial analysis.
This hands-on workshop provides a fundamental introduction to spatial data analysis using the R programming language. Participants will explore two core spatial data models, namely vector and raster, using modern packages for processing, analyzing, and visualizing spatial datasets. The workshop will cover key concepts related to spatial data structures, coordinate reference systems, and geospatial operations, with a primary emphasis on application and exercises. After completing the workshop, participants will have acquired the practical skills necessary to integrate spatial data into their own research and projects.

Outline of the tutorial

1. Introduction (15 min)
2. Raster data processing (45 min)
3. Coffee break (15 min)
4. Vector data processing (45 min)
5. Spatial data visualization (45 min)
6. Q&A (15 min)

Link to the tutorial materials (if available)

The materials (in the form of notebooks) will be made available on GitHub before the workshop begins.

Speaker: Krzysztof Dyba (Adam Mickiewicz University in Poznan)

Repository with workshop materials

5 Modelling spatial density of geo-located point data

This workshop introduces participants to the analytics of spatial geo-located point data. It starts with data processing (reading to sf class, visualisation in ggplot, plot and interactive mapview, CRS re-projecting); then it continues with detection of density clusters (QDC, DBSCAN), degree of agglomeration (using entropy-based ETA and SPAG) and comparison of density patterns by further processing KDE (Kernel Density Estimation) results (k-means and hierarchical clustering, Rand Index for similarity of clusters). It presents how to determine local neighbourhood structure across space using k-nearest neighbours, radial catchment areas, rasters, and spatial weights matrices. All those methods are applied to business locations and population settlement – the interpretation focuses on understanding differences in the spatial distributions of socio-economic phenomena within the region. Participants will learn practical techniques for handling real-world spatial data with special focus on reproducibility on the own dataset. The tutorial is based on the content of the book by K.Kopczewska (2025) titled “Modelling Spatial Density: Data, Methods, and R Applications in Statistics, Econometrics, and Machine Learning” (Oxford University Press), while online resources are available at https://rpubs.com/Kathy_Kopczewska/1244082. It will use the spatialWarsaw R package (available at GitHub).

Speaker: Prof. Katarzyna Kopczewska (University of Warsaw)

10:00 Coffee Break

12:00 Lunch

Tutorials: Afternoon Block

6 Building AI-Powered Data Pipelines with blockr: From Visual Analysis to Custom Extensions

Data analysis in R requires writing code, which remains a barrier for many domain experts. blockr is an open-source visual programming framework for R that allows users to construct reactive data pipelines by assembling modular blocks through a point-and-click interface. The framework generates reproducible R code automatically.

This hands-on tutorial takes participants from first use to block extension development. The first half of the tutorial focuses on building complete analysis workflows: loading data, applying dplyr transformations, creating ggplot2 visualizations, and exploring the pipeline structure through interactive DAG views. The generated R code can be inspected and exported at every step. Participants also experience blockr's AI integration, using natural language to configure blocks and guide their analysis.

The second half addresses the developer perspective. Attendees learn how blocks are structured (state management, expression evaluation, UI generation) and build their own custom blocks by wrapping R functions. We then cover blockr's plugin architecture and show how to add AI-powered configuration to custom blocks. The session concludes with packaging blocks for distribution and deploying applications on Shiny Server or Posit Connect.

All tutorial materials will be provided as an R package with exercises.

blockr is generously funded by Bristol Myers Squibb and is fully open source.

Outline of the tutorial

• Introduction and setup (15 min)
• Building a first pipeline: load data, filter, select, visualize through the UI (25 min)
• AI-powered analysis: configure blocks with natural language (20 min)
• Advanced workflows: multiple data sources, joins, DAG visualization, code export (20 min)

Break (15 min)

• Block architecture: state, expressions, UI, authoring rules (20 min)
• Building a custom block: wrap an R function into a blockr block (25 min)
• Plugins and AI integration: plugin system, AI configuration for custom blocks (25 min)
• Packaging and deployment: bundle blocks into a package, deploy with Shiny Server or Posit Connect (15 min)

Biography of the instructors

Christoph Sax is product owner of blockr and a founder of cynkra. He is associate editor of the R Journal and has authored several CRAN packages on time series.

David Granjon leads frontend development of blockr at cynkra. He is the author of Outstanding User Interfaces with Shiny (Chapman & Hall, 2022) and a founder of the RinteRface organization.

Speakers: Christoph Sax (cynkra GmbH, University of Basel), David Granjon (cynkra GmbH)

Building data apps with blockr

7 CANCELLED - Energy Systems Modeling with R

Energy Systems optimization models, also know as Macro Energy System (MES) models are the key tools to evaluate energy transition and decarbonization strategies for countries, regions, and globally. The workshop introduces a set of tools and open datasets to design and compare energy transition scenarios, compile reports, all not leaving R. Hands on sessions will focus on preparing datasets for the models, evaluating solar and wind energy potential for a region, designing and evaluating technologies, adjusting the modeling scope and horizon, designing policy scenarios, solving the models, and processing the results. Participants will learn the basics of the models and their potential application by designing and running the example models in R, and will be able to use pre-existing open models for different countries.

Speaker: Oleg Lugovoy (Optimal Solution LLC)

8 Exploring and visualizing data subsets using the vtree package

Suppose you want to know how many companies there are with over 100 employees in each region of several countries. We could write this as country >> region >> company >> employees. With just two variables, you can make a two-way table of counts with row or column percentages. But this does not easily generalize to larger numbers of variables, and attempts to display this kind of information can be hard to interpret. The vtree package provides a general and easily-interpreted way of displaying “variable trees” giving the size of nested subsets of an R data frame, along with tools for pruning, displaying additional summary information, customizing, and more. I first released the package in 2018 and since then my experience using vtree, along with that of many others, has shown where vtree fits in the toolbox of methods for exploratory data analysis and data visualization.

This interactive tutorial will cover the basics of using vtree, including a wide variety of examples. More advanced and special-purpose features will also be explained. Participants in the tutorial will have the opportunity to work through construction of variable trees and how to choose the order of variables, whether and how to prune, and what kinds of summary information to display. An extended example will demonstrate how to generate CONSORT-style study flow diagrams reproducibly. Additionally, other tools (e.g. UpSetR) will be compared to vtree. The tutorial will be informal and audience participation will be welcome.

Speaker: Nick Barrowman (Children's Hospital of Eastern Ontario Research Institute, University of Ottawa)

fifa_prepare.Rmd

matches_1930_2022.csv

presentation-useR!2026.pptx

traffic_stops.csv

traffic_stops_prepare.Rmd

WHO_indicators.csv

WHO_indicators_prepare.Rmd

9 Introduction to Parallel Processing in R using Futureverse - Easier than Ever Before

This tutorial provides an introduction to the Futureverse (https://www.futureverse.org), a cohesive package ecosystem designed to facilitate and simplify parallel and distributed computing in R.

While accessible to beginners and those with some R experience, this workshop also provides valuable insights for more advanced users. We will focus on the new futurize() function, which dramatically simplifies parallelization by automatically converting common R code directly into concurrent equivalents, e.g. ys <- map(xs, fcn) |> futurize(). You will learn how to scale up your existing workflows, including those using base R and purrr. We will also cover how domain-specific tasks in areas like statistics and machine learning provided by packages such as boot, caret, lme4, glmnet, and mgcv can be parallelized equally easily. The futurize() function allows us to preserve the core logic and syntax and minimizes the need to learn complex parallel APIs.

To deepen our understanding, we will explore the concept of futures, a mechanism underlying most parallel processing. By gaining an intuition for what a future is, you will develop a better understanding of how parallel processing works and see that it is actually quite simple. This deeper knowledge also applies when working outside of the Futureverse, such as with the built-in parallel package or third-party tools like foreach and mirai.

Time permitting, the tutorial concludes with an example of parallelizing via a peer-to-peer (P2P) cluster shared among participants.

This year's focus on the futurize package differentiates this session from past Futureverse tutorials by removing the need to program directly toward specialized packages like future.apply, furrr, and doFuture, which further lowers the mental threshold for starting with parallel processing.

Speaker: Henrik Bengtsson (University of California San Francisco (UCSF))

10 LeaRn and teach at the same time with Pair Programming – code storytelling activity

Would your code be better if you had someone by your side to talk through it? Or would your code be clearer if you might have to hand over the keyboard to someone at any moment?

Pair programming is a collaboration technique widely used in the software industry – it involves two people working together on one programming task. One person is the driver, suggesting solutions and typing the code; the other person is the navigator, helping with problem-solving and spotting mistakes. After a short time, they swap roles.

Pair programming can improve the reproducibility of your data analysis and quality of your code. It is also useful in teaching – making data analysis and statistics courses more interactive and more scalable (students help each other first, before coming to the instructor for help). Whether you are a teacher or not, pair programming is a method to teach and learn at the same time while building community.

In this interactive workshop, we will give you a taste of pair programming, with tasks in R. We will introduce the concept, its structure, and provide a live demo covering practicalities such as sharing code when switching roles and mindsets for success. Then you will be paired with another person and given a set of small challenges to solve together. The best way to understand pair programming is to experience it! You will practice both pair programming roles, and you will get a chance to reflect on your experience, leaving ready to try pair programming in your own context.

Speakers: Dr Pawel Orzechowski (The University of Edinburgh), Dr Brittany Blankinship (The University of Edinburgh)

GitHub Repo

11 Quarto and AI for reproducible documents

Abstract. This workshop introduces participants to using the Quarto system for creating reproducible documents. Participants will learn how to create Quarto documents, including a complete workflow from data loading and wrangling to analysis and automated document generation. The final document format can be many; however, the workshop focuses on DOCX with custom styling.

Outline of the tutorial. Introduction to Quarto: basics of Markdown, code snippets, computation flow, and custom styles for DOCX. (50 min) Coffee break. (10 min) Introduction to local AI: API key handling, ellmer package with chat and tools. (50 min) Coffee break. (10 min) Creating a reproducible workflow. (60 min)

Speaker: MIchał Ramsza (SGH Warsaw School of Economics)

14:30 Coffee Break

Keynote: Welcome & Opening

Convener: Przemyslaw Biecek (Centre for Credible AI)

Social: Welcome Reception

Tuesday 7 July

08:00 Registration open

08:30 Coffee Break

Keynote: Interactive Graphics for Understanding and Interpreting Nonlinear Model Behaviour in High Dimensions, using R

Conveners: Dianne Cook, Przemyslaw Biecek (Centre for Credible AI)

12 Interactive Graphics for Understanding and Interpreting Nonlinear Model Behaviour in High Dimensions, using R

Abstract:
When crossing a busy street, we understand that keeping our eyes open isn't optional—it's how we stay safe. Yet when building complex models, we often choose to work blind. Some of this is understandable — visualising high-dimensional data is genuinely difficult. But cultural attitudes matter too: there's a lingering belief that "looking at the data" compromises objectivity, and a tendency to view diagnostics as about as appealing as cleaning house. Yet the landscape is shifting. Visualising high dimensions is getting easier, and explainability is now considered as important as predictive accuracy.

This talk demonstrates how to open our eyes when building models. I'll begin with the Rashomon quartet, showing how visualising the simulated training data reveals why four equally high-performing models yield strikingly different interpretations - an example of visualising fitted models relative to observed data.. I'll then tackle a critical challenge: local model explanations often conflict, and interactive graphics in high dimensions can help determine which explanations are trustworthy. Finally, I'll outline practical ways to integrate these visual methods into the tidymodels workflow, making visualisation a natural part of model development.

Bio:
Dianne Cook is a Professor of Statistics in Econometrics and Business Statistics at Monash University in Melbourne, Australia. She holds a PhD in Statistics from Rutgers University. Her research focuses on statistical graphics, with an emphasis on interactive visualisation of high-dimensional data and statistical inference for data visualisation. Di is a Fellow of the American Statistical Association, elected member of the International Statistical Institute, and a Board Member of the R Foundation. She is a past editor of the Journal of Computational and Graphical Statistics, and The R Journal, and author of numerous R packages. She is actively involved in R Ladies Melbourne, the Statistical Computing and Visualisation Section of the Statistical Society of Australia, and the Graphics and Computing Sections of the American Statistical Association.

Speaker: Dianne Cook

10:00 Coffee Break

Talks: Case studies and applications

Convener: Kevin Patrick O'Brien

13 Analyzing Sports Data with R

LeBron choosing between taking a mid-range shot and feeding a teammate for an open three-pointer; Verstappen heading towards the pit lane or driving another few laps with the current tires; Sinner going all-in on a second serve against Alcaraz. Making split-second decisions when the stakes are the highest requires the talent and hard work that only great athletes have. Analysis of sports data has grown exponentially the last quarter century, providing sports performers with precise information to support their abilities. In this talk we'll show sample basic analysis from a variety of sports, leveraging domain specific R packages and publicly available data sets and provide tips to UseRs aspiring to use their skills in the sports domain.

Speaker: Max Marchi (Cleveland Guardians)

ASDWR_presentation.html

ASDWR_presentation.html

14 Workforce Digital Twins: Individual-Level Stochastic Simulation for Strategic Workforce Planning in R

Traditional workforce analytics relies on aggregate metrics that obscure individual-level dynamics and wash out critical correlations between employee characteristics, career trajectories, and compensation outcomes. This talk presents a Workforce Digital Twin methodology using individual-level stochastic simulation to model strategic gender pay equity interventions in a large global organisation.

The digital twin simulates year-by-year workforce dynamics where employees probabilistically experience turnover, hiring, promotions, lateral moves, and demotions based on empirically-derived transition probabilities from organisational data. By constructing enhanced Markov chains that capture cross-sectional correlations across multiple workforce dimensions simultaneously—gender, career group, tenure, remuneration—the model compensates for limited longitudinal history, enabling robust strategic planning despite shorter historical periods.

Applied to gender pay gap compliance planning under Australian workplace equality regulations (WGEA), the simulation projects workforce composition and compensation trajectories over a 12-year horizon. Multiple intervention scenarios are tested by adjusting transition probabilities to reflect strategic hiring, advancement, and retention initiatives. The simulation reveals counterintuitive intervention opportunities that remain hidden when using traditional aggregate workforce metrics.

This evidence-based approach provides organisational decision-makers with quantifiable pathways to achieve regulatory compliance targets, informing strategic resource allocation for equity programmes. The presentation demonstrates how R enables enterprise-scale workforce simulation that bridges statistical rigour with practical strategic planning. This methodology is transferable to other organisational challenges including succession planning, skills development, and workforce transformation, offering the R community a framework for individual-level organisational modelling.

Speaker: Dr Nicolas Flores Castillo (BHP, Organisational Development and Analytics)

NFC_useR2026.pptx

15 samplyr: A Tidy Grammar for Survey Sampling Design in R

In methodology reports and academic textbooks, sampling designs are described in a structured way, with an explicit logic connecting strata, clusters, sampling stages, and selection probabilities. This structure is often lost in the R code that implements it, where the design gets scattered across intermediate objects, successive calls, and technical details. The more complex the plan, the wider the gap, making code harder to read, verify, and maintain.

samplyr was built to close this gap. The package provides a declarative grammar inspired by the tidy ecosystem, where each verb maps to a sampling operation: sampling_design() to initiate a plan, stratify_by() to stratify and allocate, cluster_by() to define clusters, draw() to specify method and size, add_stage() to chain stages, and execute() to draw the sample from a frame. Complex sampling designs are expressed in code that is more structured, more readable, and closer to the statistical reasoning behind them.

The talk will illustrate this approach using several types of designs common in official statistics and applied surveys. We will show how a more explicit expression of the design can improve reproducibility, reduce implementation errors, and smooth the transition from design to sampling to analysis with survey. Born from field experience on national surveys in West and Central Africa, samplyr aims to make sampling code read the way sampling designs are written.

Link: https://dickoa.gitlab.io/samplyr/

Speaker: Dr Ahmadou Dicko

samplyr: A tidy grammar for survey sampling design in R

samplyr_dicko_user2026_standalone.html

16 Evaluating Disclosure Risk in Synthetic Data with the R Package riskutility

The growing movement toward open data, open science, and open government has increased the demand for sharing detailed microdata while protecting individual privacy. Data anonymization methods, including classical statistical disclosure control techniques and synthetic data generation, enable data sharing, but evaluating the resulting privacy risks and analytical usefulness remains challenging.

We present riskutility, an R package that provides a unified framework for assessing both disclosure risk and data utility in anonymized datasets.

The package implements a broad collection of evaluation metrics, including attribution-based disclosure risk measures (e.g., CAP, TCAP, DCAP), distance-based memorization checks such as Distance to Closest Record (DCR) and Nearest Neighbor Distance Ratio (NNDR), information-theoretic metrics, and model-based and distribution-based utility measures. In addition to these core methods, the package includes many further diagnostics for comparing distributions, multivariate structure, predictive performance, and other aspects of analytical validity. Together, these tools allow analysts to systematically evaluate privacy risks alongside analytical usefulness within a single workflow.

A central methodological contribution implemented in the package is RAPID (Risk of Attribute Prediction–Induced Disclosure), a novel inferential disclosure risk measure. RAPID models a realistic attacker who trains predictive models on released data and uses quasi-identifiers to infer sensitive attributes of real individuals. The method quantifies per-record vulnerability for both continuous and categorical sensitive variables.

Through live coding examples with a real-world dataset, this talk will demonstrate practical workflows for disclosure risk analysis, including identifying high-risk records, selecting attacker models via cross-validation, analysing which quasi-identifier combinations drive vulnerability, and exploring privacy–utility trade-offs using PCA-based visualisations.

The RAPID methodology is described in our recent work:
https://arxiv.org/abs/2602.09235

Speaker: Oscar Thees (FHWN / SwissAnon)

rapid_useR2026.pdf

Talks: Data visualization

Convener: Maciej Szymkowski (Future Processing, Bialystok University of Technology)

17 Writing Interactive Applications with Base R using getGraphicsEvent()

Interactive graphical applications in R are typically built using external web-based frameworks such as Shiny or by interfacing with other programming languages such as Tcl/Tk or JavaScript. However, these approaches may require server infrastructure or knowledge of additional programming languages.

As an alternative, the base R function grDevices::getGraphicsEvent() enables interactive graphics directly within R, without external frameworks or other programming languages. Despite this capability, the function appears to be largely unknown: only 26 packages on CRAN currently make use of it.

In this talk, I introduce the core ideas behind getGraphicsEvent() and demonstrate how it can be used to build interactive graphical applications entirely in base R. I illustrate the approach with several examples, including the plotannotate package for interactively annotating plots with freehand drawing, symbols, and text, and a chess trainer application for playing chess and practicing openings and tactics.

I conclude by discussing the broader potential of this approach for developing lightweight interactive tools in R, including dashboards, editors, and games, without relying on external frameworks.

Speaker: Wolfgang Viechtbauer (Maastricht University)

viechtbauer_user2026_interactive_apps.pdf

18 Create your own dashboard with EurostatRTool

In today's digital landscape, the demand for making statistics more accessible and meaningful to the general public is increasing. This has led to the need for fast and efficient ways to disseminate statistical information, particularly when data visualisations must be produced quickly and updated frequently. In this context, Eurostat launched a project under the ESS Innovation Agenda and developed the eurostatRTool package in R, a tool designed to facilitate statistical data dissemination.
The package provides data producers with a robust and flexible environment for creating customisable HTML dashboards to visualise and analyse economic indicators. This customisation enables data producers to select the indicators to be included and the types of visualisations to be used, tailoring the tool to their specific needs. Customisation options also include the possibility to use a specific logo, insert text in a language different from English, and update the displayed texts using simple input in files.
This visualisation tool combines interactive graphical representation with text, making it possible to convey concise messages to the reader in a storytelling format. Once customised, the EurostatRTool will rapidly generate a set of HTML pages suitable for publication on a website, without additional software requirements. While flexible enough for many applications, this tool is particularly well-suited for displaying frequently updated data, such as monthly monitoring of statistical variables, offering various settings options, including:
-use of specific branding and visual identity
-easy updates of the storyboard with the use of text input files
-use of interactive presentations, such as graphs with interactive charts (time span, selection/deselection of variables, etc.) and table formats
-effortless updates for regular data changes
The tool is freely available on GitHub, with code and wiki documentation, at: https://github.com/eurostat/eurostatRTool

Speaker: Antonio Grosso

EurostatRTool_USER.pptx

19 Reusing 'ggplot2' code: how to design better plot helper functions

Wrapping 'ggplot2' code into plot helper functions is a common way to make multiple versions of a custom plot without
copying and pasting the same code over and over again. Helper functions can replace long and complex 'ggplot2' code
chunks with just a single function call. However, if that single function is not designed carefully, the initial convenience can
often turn into frustration. While helper functions can reduce the amount of code needed to remake a complicated plot, they
often mask the underlying layered grammar of graphics, complicating further customisation and tweaking of the plot.
This talk addresses how to design effective 'ggplot2' plot helper functions that maximise reuse convenience whilst
preserving access to the elegant flexibility of layered plot composition. By studying existing 'ggplot2' extensions for
producing calendar plots, we identify a number of common pitfalls, including overly specific function arguments and hidden
data manipulations. Then, we discuss how to avoid these pitfalls and retain the benefits of 'ggplot2' by: separating data
preparation from plotting, utilising list arguments for customisation, and providing transparent documentation. We illustrate
these strategies using examples from the design of the 'ggtilecal' package, which provides helper functions for plotting
calendars using the geom_tile() geometry from ggplot2.

Speaker: Cynthia Huang (LMU Munich)

Reusing ‘ggplot2’ code: how to design better plot helper functions

slides.pdf

20 Interactive Graphics for Analyses, Documents and Dashboards

The R ecosystem provides very good infrastructure for making R accessible as web-based documents, dashboards and for performing remote analyses. This opens up the possibilities for using interactive graphics which are important both for exploratory data analysis and presentation. However, most such solutions consists of simply binding exisiting JavaScript libraries which are often designed for different purposes or not leveraging the vast body of research in the area of statistical graphics. In this talk we will present a modern implementation of web-based statistical interactive graphics both with full integration with R and for offline distribution and deployment in documents or dashboards.

Speaker: Simon Urbanek

Talks: Econometrics and financial modeling

Convener: Olgun Aydin (Gdansk University of Technology)

21 When One Hundredth of a Second Matters: Bayesian Counterfactual Modeling in R

At the 1980 Winter Olympics, the men’s 15 km cross-country skiing race was decided by one hundredth of a second. Rather than debating historical causes, we treat this as a modeling problem: could a physically plausible effect—such as a small change in aerodynamic drag—have been large enough to matter?

In this talk, we demonstrate how Bayesian forward simulation in R can be used to reason about extreme performance margins under limited data. Using publicly available split times and a realistic proxy for course profile, we construct a physics-informed probabilistic model of aerodynamic drag. Key uncertain quantities—frontal area, drag coefficient, and power output—are represented as prior distributions. We then propagate uncertainty through the model to obtain a posterior distribution for time loss attributable to drag.

The resulting visualization makes a subtle point clear: margins commonly described as “negligible” may lie well within the distribution of physically plausible outcomes. The emphasis is not on rewriting history, but on illustrating how R can be used to formalize counterfactual reasoning, propagate uncertainty, and communicate probabilistic thinking in an intuitive way.

The talk focuses on reproducible simulation, transparent assumptions, and effective visualization strategies for Bayesian reasoning in applied contexts.

Speaker: Kristian Vepsäläinen (freelance data scientist)

mieto-wassberg-useR2026.html

One Hundredth of a Second: A Bayesian forward simulation of aerodynamic drag at the 1980 Olympics

22 mlr3forecast: Extending mlr3 to time series forecasting

mlr3forecast extends the mlr3 ecosystem to support time series forecasting workflows. It introduces a dedicated forecasting task class and resampling strategies that respect temporal ordering, enabling forecasting models to be benchmarked, tuned, and combined in a systematic way. Learners wrapping established forecasting methods such as ARIMA and ETS can be used alongside any mlr3 learner adapted to forecasting tasks, enabling hyperparameter tuning with mlr3tuning, preprocessing pipelines with mlr3pipelines, and benchmarking within a single consistent interface. In this talk, we will give an overview of mlr3forecast's design and key features and demonstrate its application in practical forecasting and benchmarking scenarios. https://github.com/mlr-org/mlr3forecast

Speaker: Maximilian Mücke (LMU Munich)

mlr3forecast-user2026.html

23 SerolyzeR - an R package for automated analysis of serological data

Pre-processing and quality control of high-dimensional serological data from Multiplex Bead Assay machines pose a significant bottleneck to the responsible application of machine learning to global health challenges. Driven by the data demands of the PvSTATEM project, an international initiative aimed at malaria elimination, we developed SerolyzeR, an open-source R package designed to streamline this computational workflow.
The package provides researchers and field scientists with accessible, automated tools for quality control and consistent data normalization via parametric standard curve fitting. By parsing multiple Luminex output formats (including xPONENT, INTELLIFLEX, and BIOPLEX) into a unified dataset, the package eliminates formatting inconsistencies and facilitates seamless cross-experiment comparisons. While initially created to support responsible machine learning in the fight against malaria, SerolyzeR offers a robust, generalizable solution with broad applications in disease surveillance and pathogen research. The source code and detailed documentation for the package are available at https://github.com/mini-pw/SerolyzeR.

Speakers: Jakub Grzywaczewski (Warsaw University of Technology), Dr Nuno Sepúlveda (Warsaw University of Technology)

Talk_UseR_nunosep.pdf

24 No code, no limits: blockr, a visual AI driven data pipelines builder for R.

We are delighted to introduce 'blockr', a visual, block-based interface for building, customising, and sharing interactive R data workflows, without any coding experience.

'blockr' enables users to snap together modular blocks for data loading, transformation, visualisation, and export, forming directed acyclic graph (DAG) pipelines with instant visual feedback. It carefully integrates AI tools, to assist users in building workflows and configuring blocks, further lowering barriers for non-programmers and accelerating app creation. Every project can be saved, restored and exported as clean reproducible R code. The 'blockr' ecosystem includes blocks for data wrangling and visualisation (dplyr, tidyr, ggplot2, ...), time series, AI assistants, and domain-specific tasks, to cover most use cases (https://bristolmyerssquibb.github.io/blockr/). Programmatic APIs exist to create new blocks or even larger extensions such as markdown reports and slides deck builder, thereby adapting to all R users needs. 'blockr' can be used for a wide range of tasks, from building single-page or multi-tabs dashboards, to automating data workflows such as file conversion, cleaning, and export, or teaching data science (https://blockr.cloud/).

'blockr' is currently utilised at BMS (Bristol Myers Squibb), from where it is sponsored, to power clinical applications such as patients safety explorer or in the automation of complex statistical table generation. It is also applied in insurance and sport analytics.

Speaker: David Granjon (cynkra GmbH)

blockr: a visual, AI-driven data pipeline builder for R

index-selfcontained.html

Talks: Package development

Convener: Uwe Ligges

25 R We There Yet? Surviving the Transition to Package Maturity

You’ve built a great R package. People are using it. Feature completeness is in sight. Congratulations - you’ve defied the odds. Now the hard part begins!

Transitioning an open-source R package from active development to long-term maintenance and stability is a complex shift. Throughout this talk we’ll explore methods to tackle this often overlooked, but key challenge of the open-source lifecycle: how can you sustain your development team's momentum (or just your own!) without chasing perfection, in a time where the active workload is naturally diminished? What should your new priorities be? What do stability and maintenance even mean?

Along the way, we’ll draw insights from the pharmaceutical industry, analysing how the {admiral} package navigated these challenges while managing a large-scale open-source framework. We will discuss how to redefine your priorities, protect your package's stability, and keep a development team engaged during the shift to maintenance mode. Because a package's true legacy isn't just built during the chaotic first release, but in the quiet years of reliable stability.

Speaker: Edoardo Mancini (Roche)

R We There Yet_ Surviving the Transition to Package Maturity.pptx

26 Maintaining a package on CRAN

Publishing a package on CRAN is often half the work of a maintainer, then comes the hardest part: maintaining it there. Many resources focus on getting the package published on CRAN and what it takes one maintainer to do so. They share common problems and how to solve them but they are not based on data or focused on maintaining the package on CRAN.

Recently, CRAN has open up some historical data about actions take with packages. These datasets contain the historic data of each action from the CRAN team in relation to published packages. With these datasets we will learn how often are packages updated and archived. Then, we will explore characteristics related to a package staying longer on CRAN and how they reacted to CRAN's emails to update packages. Last, we will learn what are the common causes that require a package update or lead to them being archived.

With all this together we will learn what it takes to publish a package on CRAN, update it and keep it working for all users with the high quality R is known for. This will help reducing the friction between package developers and CRAN volunteers and keep publishing great packages.

Speaker: Lluís Revilla Sancho

maintaining_pkg_on_cran_Lluis_revilla_useR2026bb.pptx

maintaining_pkg_on_cran_Lluis_revilla_useR2026.pdf

27 UnitMix in Production: Multivariate Gaussian Mixtures for Robust Detection of Scale Errors and Outliers

UnitMix is an R package designed to detect and correct unit of measurement errors using Gaussian mixture model-based clustering, supporting both methodological research and production workflows at National Statistical Institutes (NSIs).
The core function, assign.cluster, implements a multivariate Gaussian mixture model on log-transformed variables, allowing clusters to be defined simultaneously over more than two variables through user-defined error patterns, and providing uncertainty aware assignments via probability and entropy thresholds. This talk presents the evolution of UnitMix, emphasizing the new refine.cluster functionality and its role in robust post processing of multivariate cluster assignments.
The refine.cluster function evaluates the compatibility of each record with its assigned cluster via Mahalanobis distance, using a chi-square cutoff to identify outliers and unstable groups based on within cluster compatibility and minimum size constraints. Records that fail these checks, or that belong to clusters with low proportions of compatible units, are automatically moved to an unassigned cluster, improving the reliability of edited data. We illustrate how this refinement step has been integrated into Istat’s operational pipelines for the energy consumption surveys of households and enterprises, where systematic scale errors and structural outliers are frequent. In addition, we show its use in the acquisitions section of the Small and Medium Enterprises (SME) survey.
The contribution will focus to the advantages related to moving from ad-hoc scripts to a reusable package that supports transparent, reproducible editing workflows in official statistics.

Speaker: Cristina Faricelli (ISTAT)

useR! 2026_Faricelli_UnitMix.pdf

28 What If We Break Base R? Bug Propagation in CRAN

With over 23,000 packages, CRAN forms a large ecosystem of reviewed code. Additionally, its strict rules and dependency structure make it great for analyzing bug propagation in an ecosystem.

This talk presents a hypothetical scenario in which I introduce a bug into base R. I analyze the consequences for the entire ecosystem and whether packages themselves would catch those bugs with their unit tests before serving incorrect results unbeknownst to users. To do so, I prepared a pipeline that introduces a bug into one of the base functions and runs R CMD check on the packages that use this function the most, as well as the reverse dependencies of those packages. Then it compares these results with those obtained with unmodified R. This allows me to construct and analyse a dependency and failure network, which can be checked for resilience and the ability to capture bugs.

The main goal of this presentation is to show how I built and analyzed these networks. I will answer questions about how many packages caught the bugs, whether failures formed any interesting structures, and also hope to address a more general question about how well we test our packages. The talk also deep-dives into the tools used to alter base R and run R CMD check in its buggy state. I will also provide details on how everything was orchestrated using the checked package and subprocesses to maintain different R states. An approach that can be reused in different projects.

Speaker: Szymon Maksymiuk (WUT)

What If We Break Base R_.pdf

Lightning Talks: Case studies and applications

Convener: Kevin Patrick O'Brien

29 bbk: Accessing Central Bank Data in R

bbk provides a unified R interface for accessing data from major central banks, including the Deutsche Bundesbank, European Central Bank, Swiss National Bank, and Bank of England. Central bank data is widely used in economic research and financial modeling, yet each institution exposes its own API with different conventions, making reproducible data access cumbersome. bbk abstracts over these differences, providing a consistent interface. In this talk, we will give a brief overview of bbk's design and demonstrate how it simplifies access to central bank time series for research and analysis. https://github.com/m-muecke/bbk

Speaker: Maximilian Mücke (LMU Munich)

bbk-user2026.html

30 paperboy - A Collection of News Media Scrapers in R

The philosophy of the R package paperboy is that the package is a repository for webscraping scripts for news media sites, with advanced features for quick data retrieval - even for content behind log-ins or anti-scraping measures. Many data scientists and researchers write their own code when they have to retrieve news media content from websites. At the end of research projects, this code is often collecting digital dust on researchers hard drives instead of being made public for others to employ. Paperboy offers writers of webscraping scripts a clear path to publish their code and earn co-authorship on the package, while promising users to deliver news media data from many websites in a consistent format. With 179 covered as of today and a default scraper that often works well enough, paperboy can already facilitate a large range of research projects.

Speaker: Sina Chen (GESIS Leibniz Institute for the Social Sciences)

useR_talk_paperboy.pdf

useR_talk_paperboy.pptx

Lightning Talks: Data visualization

Convener: Maciej Szymkowski (Future Processing, Bialystok University of Technology)

31 SweEpiAI: An LLM-Powered R Shiny Application for Natural Language Exploration of Swedish Epidemiological Data APIs

Background: Public health databases often present barriers to non-technical users through complex query interfaces requiring knowledge of variable codes and API structures. The Swedish National Board of Health and Welfare maintains a comprehensive statistical database on disease prevalence and hospital care, yet exploring these data programmatically demands substantial technical expertise.
Objectives: To develop SweEpiAI (https://sweepiai.vitiscience.se/), an interactive R Shiny application that enables natural language querying and visualization of Swedish epidemiological data APIs through integration with large language models (LLMs).
Methods: SweEpiAI is built with the Rhino framework for R Shiny, using the ellmer package to interface with GPT-4.1. A multi-step LLM orchestration pipeline processes user queries: (1) query decomposition parses natural language into structured dimensions (diagnosis, region, age group, sex, time period); (2) metadata lookup retrieves available variables from the API; (3) API URI generation constructs valid requests; and (4) validation ensures query correctness before execution. Data are fetched in parallel using the furrr package and visualized interactively with echarts4r. The application includes Auth0 authentication, a PostgreSQL backend via Supabase, and is deployed using Docker and ShinyProxy.
Results: SweEpiAI allows users to ask plain-language questions, such as "How many patients with breast cancer were recorded in Sweden in the last five years?", and receive interactive charts and downloadable tables with customizable grouping and faceting. Pilot testing with researchers demonstrated the application's effectiveness in lowering barriers to epidemiological data exploration. Participants expressed interest in the integration of additional databases such as the Prescribed Drug Register
Conclusion: SweEpiAI demonstrates how LLM integration with R Shiny can democratize access to public health data, reducing technical barriers while maintaining data fidelity. Planned developments include expanding the range of supported data sources and enhancing query capabilities based on user feedback.

Speaker: Dr Máté Szilcz (Viti Science)

Mate Szilcz SweEpiAI useR! Conference Lightning Talk 2026-07-07.pptx

Lightning Talks: Econometrics and financial modeling

Convener: Olgun Aydin (Gdansk University of Technology)

32 Causal Inference with marginaleffects

Policy debates, product decisions, and scientific claims all hinge on a simple question: what would happen to Y if we changed X? In this talk, I will present a practical causal inference workflow in R, using the marginaleffects package. This package offers a consistent interface for causal inference, and it is compatible with virtually all model-fitting packages in the R ecosystem. The key causal inference approach that we will focus on is called "G-computation," a flexible strategy that accommodates rich model specifications while producing estimates of easy-to-understand and useful quantities like the Average Treatment Effect, Average Treatment Effect on the Treated, or Conditional Average Treatment Effect. The talk includes brief, reproducible examples and emphasizes model-agnostic post-estimation tools that work with linear models, generalized linear models, and more flexible specifications. The audience will leave with a practical template for causal estimation and communication, plus a set of concise code patterns for common estimands.

Speaker: Vincent Arel-Bundock (Université de Montréal)

arel-bundock_lightning.pdf

33 Empowering African Life Scientists Through R: Outcomes of a 3-Day Bioinformatics Outreach Nigeria Training

Computational literacy remains a critical gap among life scientists in sub-Saharan Africa, limiting their contribution to global science and competitiveness in data-driven research careers. Bioinformatics Outreach Nigeria (BON) organised a 3-day intensive R training for life scientists, covering base R, data types and structures, data cleaning, tidyverse-based manipulation, and ggplot2 visualisation, using life sciences examples throughout (gene expression, ecological data, clinical datasets).
Pre-training surveys (n ≈ 200) revealed that approximately 65–70% of participants had no prior R experience, with most self-rating confidence in base R, tidyverse, and ggplot2 as 1–2 on a 5-point scale. Despite limited exposure, nearly all participants rated R as "extremely important" for their academic and career goals, indicating strong motivation.
Post-training evaluations showed high satisfaction: the majority rated overall quality as "Excellent" or "Good," and most found life sciences examples "highly relevant." A 20-item applied knowledge assessment demonstrated meaningful skill acquisition, with most participants correctly answering questions on data structures, filter(), mutate(), group_by(), and ggplot2 syntax. Nearly all respondents indicated they would "definitely" or "probably" recommend the training to peers.
The dominant improvement suggestion — raised by a substantial majority — was extending training duration to at least one week, with additional requests for prompt sharing of session recordings and more hands-on exercises.
This work demonstrates that targeted, context-relevant R training can meaningfully shift computational confidence in underrepresented scientific communities, and contributes practical insights for designing inclusive R outreach programmes globally.

Speaker: Seun Olufemi (Bioinformatics Outreach Nigeria)

BON_R_Training_LightningTalk.pdf

Lightning Talks: Package development

Convener: Uwe Ligges

34 roxyreqs: Adding roxygen2-style documentation to testthat

R has excellent tooling for documenting functions via roxygen2, but no equivalent for test cases. Who wrote a test? Who reviewed it? What requirement does it verify? This information often lives in comments or external documents - disconnected from the code.

The roxyreqs package extends roxygen2 to support @meta tags above test_that() blocks:

#' @meta author Alice
#' @meta reviewer Bob
#' @meta review_date 2025-01-15
#' @meta description Validates input parsing
test_that("parse_input handles edge cases", { ... })

A custom JUnit reporter exports this metadata for automated reporting, similar to pytest for Python. Validation functions ensure all tests contain required tags. This is a first step toward generating validation documentation directly from code.

This approach is especially useful in regulated industries, such as pharma and finance, where traceability between requirements and tests is mandatory. But any team benefits from clearer test ownership and structured metadata for reporting.

The package also supports @meta tags for function documentation, enabling requirement IDs for traceability and risk classifications for compliance assessments.

roxyreqs is currently used internally but will be released as open source - we welcome feedback from the R community.

Speaker: Moritz Lang (Roche)

roxyreqs-user2026.html

roxyreqs-user2026.pdf

12:00 Lunch

Data Whiz Challenge

Talks: Measuring the Invisible: Investing in R's Core Infrastructure

Convener: Heidi Seibold (Digital Research Academy)

35 Measuring the Invisible: Investing in R's Core Infrastructure

The R language provides essential infrastructure for statistical computing, research, and data science worldwide. Yet, the labour that sustains this infrastructure remains largely invisible: maintaining legacy upstream code, triaging complex systems-level bugs, and hardening build pipelines. This work underpins the reliability and security of the ecosystem, but remains difficult to measure, resource, and systematically support.

In 2025, the Sovereign Tech Agency invested in work to strengthen and sustain R as a critical open-source infrastructure. The investment focused on improving the security, stability, and reusability of the R ecosystem. Some of the tasks involved the modernization of CRAN packages, bug fixes, and implementation of better provenance and documentation of R’s internals and architecture.

This talk presents both the technical outcomes of this investment and a methodology for evaluating its impact. Recognizing that much of the work done by maintainers cannot be captured by quantitative metrics alone, we aligned the project’s sustainability goals (reliability, security, and reproducibility) with concrete questions, such as: “Did the investment improve outreach and lower barriers for new contributors?” We then mapped these questions to quantifiable metrics, combining qualitative insights from maintainers with quantitative data to assess impact. The resulting methodology provides a framework for evaluating investments in open-source infrastructure, with broader implications for funding agencies and maintainer communities. This work demonstrates how public investment can measurably improve the sustainability of critical open-source infrastructure.

Speaker: Laia Domenech-Burin (Sovereign Tech Agency)

user_presentation.html

Talks: R in production environments

Convener: Gergely Daroczi

36 Fuzz Testing R-Based Research Software for Robustness

Fuzz testing is a technique that generates random, unexpected or malformed
data and feeds them into a program. By observing how the software behaves
under such conditions, this approach may uncover potential weaknesses,
vulnerabilities and security flaws in applications.

A dynamically-typed language such as R poses some difficulties to fuzz testing,
as by definition no predefined typing information is available: typing only
occurs at execution time, and the task of rejecting invalid inputs thus falls
solely on the package developer.

The CBTF ("Caught by the Fuzz!") package implements a fuzz testing approach
designed specifically to improve robustness of R packages by identifying
function arguments that do not have sufficient argument validation. Besides,
fuzz testing can identify sets of inputs that, while satisfying the implicit
typing of a function signature, are problematic inside the function body.

We will detail how this testing approach has contributed to the robustness of
the research software package Luminescence, discovering over 270 failure cases,
which often (but not exclusively) concern presence of missing values, NULL
entries, dimensionality- or sign-related errors.

We will present aspects of the implementation approach of the package, such
as determining test inputs, identifying and reporting failure cases, handling
false positive results and parallelisation of execution.

Speaker: Marco Colombo (University of Heidelberg)

Fuzz_testing-CBTF.pdf

37 Beyond Code Coverage: Mutation Testing in R with MutatoR

The standard metric for testing and is widely used in R packages, for instance with testthat or tinytest. However, coverage can often be misleading: 100% coverage does not mean the absence of bugs, and line covered with a test does not mean that all behaviours flowing through this line are effectively verified.

This presentation introduces MutatoR, a new package designed to bring mutation testing to the R ecosystem. Mutation testing evaluates the quality of a test suite by injecting small, intentional errors, called mutants, into the source code (for example, changing a + to a - or > to >=). If the existing tests fail to detect these changes, the mutant survives, revealing a weakness in the test suite: the more the surviving mutants, the smaller the mutation score, and the less effective the test suite.
MutatoR is tailored to the R language and automates the generation, execution and analysis of these mutants. It can scale to large test suites by parallelizing across mutants, or capping the number of mutants when there are enough to compute a precise enough mutation score, and aims at providing a correct mutation score by detecting equivalent mutants.

The presentation will demonstrate the MutatoR workflow and discuss how to interpret mutation scores and mutants on some representative CRAN packages.

Speaker: Dr Pierre Donat-Bouillud (Czech Technical University in Prague)

Beyond Code Coverage: Mutation Testing in R with mutator

Beyond Code Coverage_ Mutation Testing in R with MutatoR.pptx

38 5 years of internal software validation in Roche

Software validation is a key part of analyses conducted in a regulatory environment, and it is crucial to document the accuracy, reproducibility, and traceability of the software used for clinical analyses. At Roche, we initially outsourced this effort to an external partner. However, this was a solution far from ideal due to, among others, bottlenecks, a fixed release schedule, and difficulties with processing ad hoc and business-critical validations. Therefore, in 2021, Roche decided to internalize this process by developing end-to-end validation pipelines that validate packages on demand and serve them in the validated packages repository.

In this presentation, we will walk the audience through this process. We intend to detail how the initial assumptions changed and what parts were the hardest, including design decisions, stakeholder alignment, and getting approval from people responsible for validation. We want to illustrate our progression and how it has positively affected us by raising awareness about high-quality R code across many parts of the company.

Furthermore, we plan to show key performance indicators and how they have evolved. The number of packages validated, time required to validate a package, number of pipelines run, etc., all of this led, through constant improvements and gradual replacement of external validation, to an 80% reduction in validation time. Our goal is to provide insights into how the validation process can evolve within the company by sharing the experience we gained, including both successes and challenges we overcame, which may be useful for companies seeking or already walking the same path.

Speakers: Szymon Maksymiuk (Roche), Lorenzo Braschi (Roche)

useR! 2026 - July 2026.pdf

39 Quality Control Risk Model for R Package Validation

There are many validation approaches for R and its packages that has a foundation in classic software and application validation, specifically how it relates to statistical analysis applications within regulated industries like Life Science. The introduction of risk-based validation approaches in the last decade has provided additional tools, but as we now approach R as a language, packages as language extensions and that we seldom independently validate languages as part of Computer System Validation, there is an inherent conflict with expectations and industry standards, guidelines and regulations, such as ICH Good Clinical Practice..

We explore a risk-based validation approach that is based on the risk that a package functions and computational methods produces an incorrect result that is not or cannot be caught by the mandated quality controlled processes, i.e. quality checks and output validation. The result is a simplified validation process that is more robust, much easier to implement, lighter on the documentation and simple to automate.

Speaker: Magnus Mengelbier (Independent / Freelancer)

user-2026-qc_risk_validating_r_packages.pptx

Sponsor Session

Convener: Heidi Seibold (Digital Research Academy)

40 Sponsor Session

Appsilon
How Appsilon useR - Marcin Dubel

cynkra
Data Workflows for All: Reproducible Data Analysis in the Age of AI - Olajoke Oladipo

R Consortium
R is People - Mike Smith

Speakers: Marcin Dubel (Appsilon), Mike Smith (Pfizer R&D UK Ltd), Olajoke Oladipo (cynkra)

Data-Workflows-for-All-Keynote-olajoke-cynkra-useR2026.pptx

user2026_sponsor_talk_MikeKSmith.pdf

user2026_sponsor_talk_MikeKSmith.pptx

Lightning Talks: R in production environments

Convener: Gergely Daroczi

41 Building the Ultimate R AI Assistant

While standard LLMs are powerful for general coding, they often fall short when working with specialized or internal R packages. This usually comes down to a knowledge gap - public models simply do not have access to private packages or the most recent documentation. To solve this, we propose a shift away from a single, all-purpose assistant toward a decentralized network of agents, where each R package is supported by its own dedicated expert.

This talk explores the architecture behind this system. By using a multi-agent framework, specialized agents are created on demand and grounded in real-time documentation to ensure technical accuracy. The session covers how stateful transitions are managed between these agents and the specific methods used to help them write, debug, and explain complex clinical code without losing reliability.

Additionally, the talk examines the technical side of managing a large network of experts as a scalable alternative to relying on one massive model. Key topics include the automated ingestion of R help files for grounding and the deployment of a backend service that supports multiple interfaces, from interactive chat to MCP servers. This session offers a practical framework for building AI tools in technical fields where precision and scalability are essential.

Speaker: Pawel Rucki (Roche)

Building the Ultimate R AI Assistant

Building the Ultimate R AI Assistant.pdf

42 R Documentation as an AI Tool

When an AI assistant suggests code for a specialized R package, it’s often guessing based on outdated or public data. We built mcp.rhelp to turn local R documentation into a tool for AI coding assistants. This lightweight MCP server allows assistants to navigate R’s documentation - finding where a function lives, reading its exact help file, and inspecting its source code. In this talk, I will show how this setup increase quality of responses by providing the AI with the relevant information. It’s a simple, focused solution for making AI assistants actually reliable for professional R development.

Speaker: Pawel Rucki (Roche)

R Documentation as an AI Tool

R Documentation as an AI Tool.pdf

43 Even faster C for ultimate R performance

It's no secret that to optimize R code one has to write it in C (or C++). This is, however, just a beginning. When does it make sense to rewrite the code? What are the typical performance sinkholes? What are the key techniques to get even more performance?

There are surprisingly few resources where you could find the answers, and my talk will try to fill that gap. Lately, I've been working on improving performance of {purrr} functions and at least one of these improvements already made it to the official release, speeding up every() and friends twice. I've learnt a lot and I want others to learn too, as there are too many packages to optimize for me to go at it alone.

Speaker: Laura Bąkała

14:30 Coffee Break

Keynote: R Under Sirens: Research, Students, and Community in Wartime Ukraine

Conveners: Dariia Mykhailyshyna, Katarzyna Woźnica (Warsaw University of Technology, Systems Research Institute of the Polish Academy of Sciences)

44 R Under Sirens: Research, Students, and Community in Wartime Ukraine

Abstract:
The talk examines the use of R for empirical research, university teaching, and community-oriented training related to Ukraine during the Russian full-scale invasion. It focuses on how R is applied in applied research projects, in classroom instruction, and in initiatives such as the Workshops for Ukraine series when work is affected by repeated disruption.

Examples will be used to illustrate how R supports empirical analysis, the preparation of teaching materials and assignments, and the coordination of collaborative and community activities under unstable conditions. The talk will also draw on feedback from R learners and users in Ukraine to distinguish between challenges that are specific to wartime circumstances and those that are likely to be common across learning environments.

Bio:
Dariia Mykhailyshyna is a postdoctoral researcher in Economics at the Kyiv School of Economics. She has obtained her PhD in Economics from University of Bologna in 2025. Her research focuses on applied microeconomics, including political economy, migration, education, labor economics. She has been an avid R user for 7 years uses R extensively for all stages of her research. In addition to her research, she teaches statistics and R to students in Ukraine and organizes the Workshops for Ukraine series, which raises funds for Ukraine by offering R training to participants in Ukraine and abroad.

Speaker: Dariia Mykhailyshyna

user-keynote.html

Lightning Talks: A

Convener: Kamil Sijko

45 Comprehensive PhD documentation with R and Quarto

A PhD is a complex, multi-year project that involves managing a diverse range of information: from meeting notes to research ideas, from immediate tasks to long-term plans. Disorganized notes and files lead to inefficiencies, loss of information, and challenges in reproducing past workflows. This lightning talk presents a comprehensive PhD documentation template built with R and Quarto, meant to serve as a searchable, structured, and comprehensive documentation of all aspects of a PhD.

The template provides a structured framework for organizing research projects, meeting notes, funding opportunities, and more. It combines reproducible reporting with lightweight automation through custom R functions that generate standardized pages for projects, meetings, and literature notes. A visual project overview, multiple summary tables, and full-text search enable users to keep track of several concurrent tasks without losing sight of long-term goals, and quickly retrieve even years-old information.

While the template is designed with PhD students in mind, it can be easily adapted to other long-term projects, including for information sharing within a team. Every aspect of the template is fully customizable, with documentation in the corresponding GitHub repository on how to do so. Page templates and some outputs are generated with R, while all pages are markdown files rendered with Quarto. The lightweight setup is suitable for both local and web-based use.

In addition to sharing a ready-to-use template, the talk highlights the importance of internal knowledge management systems as a complement to other reproducible research practices.

Speaker: Tina Rozsos (Vrije Universiteit Amsterdam)

Repo: PhD documentation template

Repo: presentation slides

slides.html

slides.pdf

46 Tracking your own time and productivity using R and Clockify

Logging your own work hours is an efficient way to work out what you spend your time on. It can be used to help you manage your time better, to ensure you spend an appropriate time on a project, or even to negotiate pay or responsibilities at work. In this lighting talk I show how I keep track of my own hours using R and an external tracking tool (here: Clockify). My goal was to make the time logging as painless and smooth as possible, while remaining informative. I show the tracking interface and workflow I use to log my hours. Then we go through extracting the information via Clockify's API. Finally, we look at how we can summarise the information contained in the logs in ways that help inform our goals. I'll show some examples of my own goals and how I use the time logs to evaluate whether I reach those goals or not (spoilers: I don't).

I chose Clockify because it had a simple interface for fast logging and (as of now) free tier. Other services surely work just as well, and the lessons on how to summarise the information downloaded form the service's API are still relevant.

Warning: Following the approach showed in this lighting talk risks exposing just how much time you actually spend on lunch.

Speaker: Håvard R. Karlsen (NTNU)

hrk_tracking_time.html

hrk_tracking_time.pdf

47 Reproducible Clinical Data Review: A Modular R and Quarto Workflow for Transparent Reporting

During clinical trials, EDC data must be reviewed regularly — from routine medical review reports to formal audit and inspection scenarios. In these contexts, reviewers do not explore data freely. They follow a predictable, structured process and need a document that clearly records what was seen, under what conditions, and what conclusions were drawn. This core distinction shapes the design philosophy presented in this talk.

This lightning talk introduces a two-layer modular framework built with R and Quarto for clinical data review. The first layer provides pre-built review modules covering demographics, adverse events, medication records, and study endpoints — each encapsulating domain knowledge and visualization logic. The second layer allows reviewers to combine modules and map Case Report Form (CRF) fields through a YAML file, without modifying the main codebase.

A key design decision is to use raw CRF data as input rather than CDISC-compliant datasets. This lowers the cognitive barrier for non-programmer reviewers while maintaining flexibility across different trials.
Every Quarto report produced by this workflow is a decision snapshot: YAML parameters and review conditions are fully preserved, creating a natural record without additional effort.
The workflow will be demonstrated using simulated CRF data, with discussion of practical design trade-offs in programmer-reviewer collaboration settings.

Speaker: Mr Winkle Lu

LT64_PPT_Winkle_Lu_Reproducible_Clinical_Data_Review.pptx

LT64_Winkle_Lu_Reproducible_Clinical_Data_Review.pdf

48 Rxsim: Reducing friction in simulating clinical trials (RCT) using R6 programming.

Simulations are a great tool to support decisions on optimal trial designs. Trial designs have evolved from simple 2-arm treatment comparison to multi-arm dose-finding, adaptive designs, and platform trials. R is a popular and important tool for those in the pharmaceutical industry. R6 programming and supporting R functions have allowed us to design a package rxsim that is flexible enough to handle different designs with minimal change of program. Specifically, we broke apart the design of a trial into different classes with their own methods for customization on trial designs and analyses with minimal coding. The package is workflow and pipeline friendly and natively works with {targets}, tidyverse, thus can be incorporated into a rapid iterative prototyping process for trial designs. This will make trial simulations a commodity and the code more reusable, standard, and reliable. From here we can hope to standardize programming of R-based trial simulations across industry and regulatory.

Speakers: Dr Matthew Valko (Boehringer Ingelheim Pharma GmbH & Co. KG), Dr Saumil Shah (Boehringer Ingelheim Pharma GmbH & Co. KG)

lightningtalk_v_1_0.pptx

49 Clinical Output Review with R

Part of the responsibilities of a statistician working on clinical trials is reviewing tables, listings, and figures (TLFs) to ensure accuracy and compliance. However, the review process can be challenging due to the volume of outputs and the dynamic nature of clinical trial data. A common issue arises when outputs are reviewed and checked, but subsequent data updates or programming changes require recreation of these outputs. Manually re-reviewing all outputs is time-consuming, error-prone, and inefficient, particularly when only a small section of an output may have changed. To address this challenge, an automated comparison workflow implemented in R can efficiently detect differences across two versions of the same output. This R-based method uses intermediate datasets, usually created with SAS, which are the final data inputs of the TLFs. However, using intermediate datasets has some disadvantages, namely this approach does not check for possible updates in titles and footnotes.

Speaker: Rozeta Simonovska

UseR2026_ClinicalOutputReview.pdf

50 R communities – from first crush to long-term relationship

The R language and R Studio are widely used in most of the federal cancer registries in Germany; but only few have special “R onboarding” programs. Therefore, a R user group “Forum R” was initiated in 2021 as part of the expert panel of the clinical cancer registries “Plattform § 65c”. This “Forum R” aims for networking and further education for employees of the cancer registries in Germany in the fields of programing, statistics, visualization and reporting with R. Currently, two elected people organize the community, which has more than seventy members from different registries, with experience levels in R ranging from complete beginners to long-standing experts.

Our biggest challenges as organizers of the group are providing content for all R programming levels as well as keeping people motivated and willing to share their work. While people often enter the group full of enthusiasm it is not easy to keep people engaged continuously especially when there is time pressure regarding other professional tasks. Doing so we complement online meetings of all group members with on-site workshops, groups of experts with specific areas of expertise, a reading group and an online ticketing system. Furthermore, we try to respond quickly to changing needs of the members of “Forum R”. Above all, the community depends on the commitment of all members.

Learning new skills and cooperating with others are among the core interests of most people. We would like to share our experiences trying to promote these human qualities.

Speaker: Ms Susanne Steinmann (Clinical Cancer Registry Lower-Saxony, Team Data Analysis)

20260707_useR_Steinmann_ForumR.pptx

51 Enabling Data Exploration Through a Metadata Layer: LLM Integration in cohortBuilder

To filter data, users need to know dataset structures, variable names, and valid value ranges. The cohortBuilder R package offers a common API for multi-step filtering across data frames, databases, and custom backends. The shinyCohortBuilder package adds an interactive Shiny GUI on top of it.

We introduce a metadata layer in cohortBuilder that connects filtering pipelines to large language models (LLMs) through tool calling. Users describe their data once with annotations and statistical summaries. Both the application and the LLM can then discover filters, read their constraints, and apply them without manual setup.

We expose cohort operations as LLM tools. These tools retrieve filter metadata, set up filtering steps, and apply values within valid ranges. The LLM turns natural language requests into filtering actions, so users do not need to (but still can) work with data schemas directly.

In shinyCohortBuilder, a chat panel lets users talk to the LLM. The LLM actions update the GUI in real time: filters appear, values change, and results refresh as the model responds.

This approach follows FAIR principles. The metadata layer makes filter definitions Findable and Accessible to both humans and machines. The source-agnostic design ensures Interoperability across different backends. By describing data once, LLMs can provide context-aware insights without users needing to learn the data model.

During the presentation, we will show a live migration from a standard cohortBuilder setup to one with LLM-driven exploration, where users interact with their data through natural language.

Speakers: Adam Forys (Roche), Krystian Igras (7N)

Enabling Data Exploration Through a Metadata Layer: LLM Integration in cohortBuilder

User!2026.pptx

52 Scaling training to infinity... and beyond!

This task will show how JupyterLite can improve a community hosted training session by reducing the friction for learners to access JupyterLab in class and later at home.

JupyterLite is a distribution of Jupyter for WebAssembly (Wasm) enabling JupyterLab to run completely (including the Jupyter server) in a modern web browser. Support to R on JupyterLite was added in 2025.

For community hosted training sessions, JupyterLite offers a zero cost solution to provide a friction-less learning experience that can be used in the classroom and at home.

During this talk, attendees will also learn about the new repo2wasm. repo2wasm is an open source tool inspired by repo2docker to help instructors to create the JupyterLite environment they will use in class.

Speaker: Raniere Gaia Costa da Silva

Scaling training to infinity.pdf

Lightning Talks: B

Convener: Sandra Binias

53 Evaluating imputation strategies for longitudinal cohort studies

Missing data is a structural feature of longitudinal cohort studies and can bias inference when attrition is systematic. We present an R-based evaluation of imputation strategies for ordinal outcomes in the Irish Longitudinal Study on Ageing (TILDA) across five waves. All data processing, simulation, imputation, and evaluation were implemented in R, enabling a fully reproducible workflow for longitudinal missing-data experiments. From a cohort of 8,504 respondents, we construct wave-specific ground-truth datasets using stratified samples of 1,000 respondents per wave (5,000 records total). Realistic Missing at Random patterns are introduced via weighted amputation with predictors of non-response estimated using penalised regression in R. We compare a deterministic mode baseline, Random Forest imputation using missForest-style iterative procedures under three mtry configurations, and Multiple Imputation by Chained Equations (MICE) with proportional-odds models. Mode imputation achieves the lowest RMSE (0.994) but introduces bias (0.079) and distributional distortion (KL 0.0293). MICE yields minimal bias (-0.036) and the strongest distributional preservation (KL 0.0009) with RMSE 1.121. Among Random Forest methods, bagged RF is most stable (RMSE 1.009), while optimised and naive configurations show higher RMSE (1.106 and 1.213) and can fail under some waves (RMSE 1.392 versus 0.894 for bagged RF in one instance). These results highlight trade-offs between point accuracy and population-level validity when imputing ordinal longitudinal health data and demonstrate the utility of R for building reproducible simulation pipelines that integrate multiple imputation and machine-learning methods in longitudinal settings.

Speaker: Dr Sinead Moylett (University of Limerick)

user_lightning_sm.html

54 Computing ROC AUC Efficiently with R

The Area Under the Receiver Operating Characteristic Curve (AUC) is a widely used measure for evaluating the performance of binary classification models. In the literature and in practice, it appears under various names and is closely related to other performance measures. We review these formulations and discuss the motivation for efficient AUC computation in empirical analysis. We survey R packages that provide implementations of AUC and describe the algorithms they employ. We then conduct a benchmarking study to compare the execution time of selected implementations. A case study illustrates how the choice of AUC computation method can substantially reduce computation time and accelerate analytical workflows in a popular package.

Speaker: Błażej Kochański (Politechnika Gdańska)

UserAUC.pptx

55 metacart 3.0: Classification and regression trees for Exploratory Moderator Analysis in Meta-Analysis

metacart 3.0 integrates regression and classification trees into the framework of meta-analysis to perform exploratory moderator analysis. Meta-regression trees identify, based on the study characteristics and their interactions, subgroups of studies that maximize within-subgroup homogeneity of effect sizes. To avoid overfitting, the resulting tree is pruned using cross-validation. Finally, subgroup meta-analysis is applied to test the significance of moderator effects.

Version 3.0 introduces several methodological advances targeting two core challenges: tree construction stability and potential bias in the statistical inference in the identified subgroups. For stability, a smooth sigmoid surrogate strategy can be used to replace a greedy search and can be complemented with a newly incorporated look-ahead strategy to improve the splitting procedure. For improved inference, a permutation test is added to evaluate the significance of $Q-$between and a bootstrap procedure is included to correct for bias in the effect size estimates of the subgroups.

Simulation study results confirm that these new features yield satisfactory false discovery rates (< .05), improve the residual heterogeneity estimation, and reduce bias in the estimates of effect sizes in the identified subgroups.

Finally, new diagnostic plots are included to visualize pruning variability and tree stability. These plots show the stability of the tree nodes and help determine the optimal size of the tree. This is a crucial decision that balances the risks of overfitting (the tree is too large) and missing moderator interaction effects (the tree is too small).

Learn more about meta-regression analysis and metacart 3.0 in this lightning talk.

Speaker: Juan Claramunt Gonzalez (Leiden University)

Metacart3_useR_2026.pdf

metacart-accessible.html

56 Let triangles solve your multinomial problems: Using simplexes to analyze low dimension trade-offs

How should we best model multinomial tradeoffs? When there are only two options that sum to 100 percent, it can be straightforward to employ options like GLM to address research questions with binomial response data, but when there are more than two groups, these multinomial models become too complex to perform and too convoluted for our audience to understand. However, using simplexes to define the experimental outcome space instead of trying to fit the data into conventional statistical space brings the inherent trade-offs of the data to the forefront and hypothesis testing becomes intuitive. In this talk I will demonstrate how two sets of data benefit from simplex analysis and how we can visualize the results easily. First, by making small modifications to the ‘Ternary’ package, I will show an experiment examining the outcome of gene knockdowns modifying the probability that a cell is arrested in different stages of the cell division cycle (G1, G2, S), and how that can be modeled using ternary diagrams. Then, using the ‘klaR’ package, I will show how this idea can be scaled into larger dimensions by highlighting an experiment examining four possible types of instruction observed in college classrooms. Finally, we will explore how the ‘plotly’ package can be modified to show tetrahedrons in three dimensions, allowing us to make interactive simplex diagrams.

Speaker: Liam Mueller (UC San Diego)

Mueller_LO_useR_Lightning_7July26.html

57 Solving Optimum Allocation Problems in Stratified Sampling Using the R Package stratallo

Optimum allocation of sample sizes across strata is a fundamental problem in survey sampling. When designing a stratified survey, researchers must decide how to distribute a fixed total sample size among strata in order to achieve specific statistical goals, such as minimizing estimator variance or minimizing survey cost subject to precision constraints. Classical results, such as Neyman allocation, provide solutions in simple settings without constraints. However, practical survey designs frequently require additional restrictions, including lower or upper bounds on stratum sample sizes, heterogeneous unit costs, or precision requirements across multiple domains.

This talk presents stratallo, an R package developed to solve several optimum sample allocation problems arising in stratified sampling designs. The package implements efficient algorithms for computing optimal allocations under a range of practical constraints. In particular, it supports three main classes of problems. First, the function opt() computes variance-minimizing allocations under a fixed total sample size, optionally subject to lower bounds, upper bounds, or box constraints on stratum sample sizes. Depending on the constraint structure, the function employs specialized algorithms such as RNA, SGA, SGAPLUS, COMA, and RNABOX.

Second, the function optcost() determines minimum-cost allocations for a specified target variance of a stratified estimator. This formulation is useful when survey planners seek to minimize survey cost while maintaining a prescribed level of precision. The implementation relies on the LRNA algorithm, which efficiently handles upper-bound constraints and heterogeneous unit costs.

Third, the package includes methods for multi-domain optimum allocation with controlled precision. The function dopt() computes allocations that balance precision requirements across multiple domains while respecting total sample size and population constraints. The problem is solved using the RDCA algorithm, which provides exact solutions and, to the best of the author’s knowledge, constitutes the first well-established exact algorithm for this class of allocation problems.

The talk will introduce the optimization formulations underlying these problems and demonstrate how they can be solved using stratallo. Several examples will illustrate the use of the package in practical survey design scenarios, including cases with large numbers of strata and domains. The package also provides artificial population datasets that facilitate benchmarking and experimentation.

The stratallo package aims to make advanced optimal allocation methods easily accessible within the R ecosystem, enabling survey practitioners and researchers to implement principled and computationally efficient sampling designs.

Speaker: Wojciech Wójciak (Warsaw University of Technology)

2026_useR_stratallo_WWojciech.pdf

58 Marrying form and function: design takeaways from an R package for estimating real-time epidemic trends from multiple streams of surveillance data

Real-time growth and prevalence of infectious diseases are vital information for epidemic response. Yet it is rare to directly observe infections, and so we must reconstruct infection trends from delayed and imperfect alternatives, including time-series of case counts and cross-sectional infection prevalence surveys. Joint inference from multiple data can improve estimates of infection trends, and reveal details about observation processes including proportions of infections observed. epiwave is an R package to access a statistical model for inferring the trend of underlying infections that can be fitted to multiple types of latent observable data. In this presentation, we highlight how we designed the interface for the software to explicitly mirror the form of the underlying statistical models. Specifically, we demonstrate the how different data inputs for each dataset are ingested in a parallel structure - designed to match the logic of model structure itself. The design principles employed present a learning opportunity for anyone interested in design of new statistical software. The flexibility in the parallel structure allows a user to incorporate any number of different data inputs using the same principles, providing support in real-time epidemic analyses where data availability can be volatile and unpredictable, especially during rapidly evolving health crises.

Speaker: Dr Saras Windecker (The Kids Research Institute, Perth, Australia)

user-epiwave.pdf

59 icsp2: Stratified interval censoring survival for clinical trial analysis

In clinical trials involving time to disease progression that can only be assessed at clinical visits, the real time to event is interval censored between visits, eg tumour assessments in progression-free survival (PFS) outcomes in oncology trials. In the typical analysis of PFS, we systematically impute the event time to be the visit where the progression was detected.

In many cases the bias from this approximation is not large, but if the censoring intervals systematically differ between treatment groups, it is not ignorable. A sensitivity analysis using interval censoring can access this bias. For a proper sensitivity analysis, we must target the same analysis method as the main analysis (apart from the interval censoring).

Therefore we require an implementation of interval-censored semi-parametric stratified proportional hazards model with appropriate variance estimates and a corresponding log-rank test.

No existing R implementation fully met these requirements. I propose a new package icsp2, which extends the algorithm from 'icenReg' for stratification and implements Sun’s interval censored log rank test, in a package with minimal dependencies.

We present the results of the verification and performance comparison against other R packages, SAS and Stata.

Speaker: Isaac Gravestock (Roche)

icsp2.pptx

Lightning Talks: C

Convener: Joanna Zyla (Department of Data Science and Engineering, Silesian University of Technology, Gliwice, Poland)

60 Why Pay for Survey Platforms? Just Use R!

Researchers conducting surveys and assessments often encounter commercial barriers. While convenient, platforms also come with substantial licensing costs, vendor lock-in, and data sovereignty concerns. Meanwhile, open-source alternatives typically require researchers to use separate tools for survey design, data collection, analysis and reporting. This creates inefficiencies, increases the risk of errors and undermines reproducibility. We introduce inrep, an open-source R package that consolidates the entire assessment workflow within the flexible R framework. With inrep, researchers can design customized assessments, manage data collection, conduct analyses, and generate personalized participant feedback reports. An accompanying Shiny app lowers the barrier to entry for initial setup, while the package's R-native design enables full integration with modern analytical workflows like adaptive testing. By eliminating licensing costs, vendor dependencies, and workflow fragmentation, inrep makes sophisticated assessment methodologies accessible to researchers, educators, and practitioners regardless of budget constraints or programming expertise, while ensuring complete transparency and reproducibility throughout the research lifecycle.

Speaker: Mr Clievins Selva (Deutsch)

61 Following Polish graduates’ pathways with R

Polish secondary school graduates tracking system has been providing data on further educational and professional careers of Polish youth annually since 2021. Moreover, the ways of disseminating these results are constantly being developed: from static, general reports to interactive dashboards that are designed to serve the needs of specific groups of stakeholders. In our presentation we will describe the various ways we use R at the Educational Research Institute in order to integrate, transform, summarize and visualize graduate data for the Ministry of Education, local authorities, school principals and the general public. We want to show how R in our system interplays with other technologies: relational databases, MS Office, SAS Viya and Posit Quarto. Moreover, we want to discuss the challenges of creating complex software solutions by a team composed almost exclusively of social scientists with very limited IT support. But also, we want to show that such difficulties can be effectively overcome, leading to the successful implementation of open, transparent solutions that serve the needs of public administration and society.

Speakers: Tomasz Żółtak (Institute of Philosophy and Sociology, Polish Academy of Sciences), Dr Grzegorz Humenny (Educational Research Institute, Warsaw, Poland), Mr Bartłomiej Płatkowski (Educational Research Institute, Warsaw, Poland)

user2026_graduate_pathways.pdf

62 From Administrative Data to Interactive Healthcare Benchmarking: An End-to-End R Workflow

Routine administrative data collected by healthcare payers hold significant potential for monitoring care quality, yet translating them into actionable insights requires careful statistical modeling and thoughtful communication. This talk presents a complete R-based pipeline — from raw reimbursement data to an interactive Shiny dashboard — developed to benchmark hospital performance for coronary artery disease care in Slovenia.
We walk through four stages of the workflow, each presenting distinct R-specific challenges. First, data quality assessment using tidyverse tooling to evaluate conformance, completeness, and plausibility of administrative records not originally intended for research. Second, dimensionality reduction via exploratory factor analysis to construct municipality-level contextual variables. Third, risk-adjusted benchmarking using generalized linear mixed effects models fitted with glmmTMB — including multilevel logistic, negative binomial, and Gamma regression — followed by indirect standardization to produce fair provider comparisons across 14 hospitals. Finally, dashboard development in Shiny, where we discuss design decisions for presenting statistically complex outputs to non-technical healthcare stakeholders in a transparent and interpretable way.
The resulting dashboard compares 13 key performance indicators across five care domains for 14 hospitals and 212 municipalities, with interactive filtering, confidence interval visualization, and regional mapping. We share practical lessons on structuring a Shiny app around mixed model outputs, communicating uncertainty to domain experts, and the broader challenge of secondary use of administrative data in R.
Attendees will leave with transferable patterns for building reproducible, model-driven dashboards in R for real-world institutional use.

Speaker: Janez Bijec (University of Ljubljana / Statistical office of Slovenia)

Janez_Bijec_presentation.pdf

63 Shiny Rhinos Docking Ducks on a Shoestring: How We Built the Austrian Health Atlas

The Austrian Health Atlas is an open-access platform using interactive charts and maps to intuitively illustrate public health data. Developed by the Austrian National Public Health Institute (GÖG), the Gesundheitsatlas shows trends, determinants and socio-economic differences in the health of the Austrian population, offering both international and subnational comparisons.
The platform's backend is built on R within the Rhino framework, so that data scientists own the full development process. This solution is vital in a publicly financed environment with limited (IT) resources. Rather than creating separate applications for each health topic, we deployed a unified, template-driven Shiny application capable of rendering any indicator dynamically. Each user session runs in its own secure Docker/Podman container, allowing for easy horizontal scalability. Under the hood, an embedded, read-only DuckDB database provides pre-aggregated health data. A lightweight background worker regularly refreshes these data and ensures seamless data updates without interrupting active user sessions. The entire development and deployment process is automated through a GitLab CI/CD pipeline.
Content management, editorial workflows and site navigation are handled entirely by the Drupal CMS, which embeds the dynamic Shiny application via an iframe. Drupal also provides a structured API that delivers the relevant metadata for each indicator. To decouple Shiny’s rendering performance from Drupal’s response times, a background worker routinely harvests this API content and caches it in DuckDB. When a user selects an indicator, Drupal passes its ID to Shiny via the page URL, enabling the app to instantly load the correct data and visualisations.

Speakers: Martin Zuba (Austrian National Public Health Institute (GOEG)), Zuzanna Brzozowska (Austrian National Public Health Institute (GOEG))

Austrian Health Atlas.pdf

64 Scientific Accountability in Shiny Apps

The principle of scientific accountability is more than reproducibility of data analysis: each result – figure, table or p-value must be unequivocally and easily tracked to the original data from which it originates. In many bioinformatics workflows this kind of accountability is difficult to maintain, particularly in interactive web applications where exploratory analyses are performed through graphical interfaces.

In this talk, I present an approach to improving scientific accountability in interactive analysis tools using a framework for building bioinformatics applications with Shiny modules, R package {bioshmods}. The framework automatically records analysis steps performed in the application and generates a corresponding R Markdown document that reproduces the complete workflow. The resulting apps can create a streamlined analysis as an R markdown file, producing publication quality results and a transparent, auditable and accountable analysis path.

The use of {bioshmods} enables developers to build interactive tools that preserve transparency and traceability while maintaining the usability benefits of graphical interfaces. I will demonstrate the framework using two applications build with {bioshmods}: {seaPiper}, for visualization of RNA-seq pipeline results, and {tmodUI}, a gene set enrichment analysis tool.

Speaker: January Weiner

weiner_useR_warsaw_202607_talk.html

weiner_useR_warsaw_202607_talk.pdf

65 How many coders does it take to write a book? Teaching Programming Across Disciplines is out now!

Coding and data have been hijacked by macho-nonsense culture (and the teaching of coding even more so). We noticed a unique opportunity to write a book comprised of a range of case studies and ideas which flip the table and flip the narrative.

Over the last 5 years we have built a community of coding and data educators who teach outside of traditional computer science settings. Our 300+ members around the world meet every year for a  Winter School  and co-author a  book called Teaching Programming across Disciplines (https://teaching-programming.github.io/book/).
Our book is an edited, open-access volume comprised of many short chapters written by groups of authors who teach across various disciplines and in several educational contexts (e.g., boot camps, higher education both undergraduate and post-graduate levels, etc.). The first edition of our book was just launched on 22 June 2026.
The first edition of our book is comprised of over 25 chapters covering topics ranging from pair programming and its applications in teaching and learning, coding anxiety, practices to foster inclusion and accessibility in programming teaching, reflections on teaching statistics and programming together or separately, and more.
Our book is a live work in progress, if you would like to join our community and/or contribute to the second edition of the book get in touch with us at pairprogramming@ed.ac.uk or our website https://pairprogramming.ed.ac.uk

Speakers: Dr Brittany Blankinship (The University of Edinburgh), Dr Pawel Orzechowski (The University of Edinburgh)

Open Access Book - Teaching Programming Across Disciplines

useR2026! Teaching Programming Across Disciplines Book.pptx

66 R as Complete Teaching Infrastructure: Automating and Enriching University Geography Education

Teaching university courses in geography, urban planning, and spatial data science demands tools that can convey place, and R is remarkably well-suited to the task. This talk presents a reproducible R-based teaching infrastructure built around several components: interactive spatially-enabled presentations, a course website ecosystem, and a reporting system leveraging the Canvas API. Lectures are built entirely in RMarkdown using xaringan, xaringanthemer, and xaringanExtra with interactive visualizations created with R packages such as leaflet, deckgl, and streetview. This enables the instructor to pan around interactive maps and streetscapes mid-lecture without leaving the presentation environment. Course materials live on a blogdown/Hugo site, giving students a persistent, version-controlled resource that is updated through the similar R-based workflow as the course slides. The author also connects to the Canvas API via reticulate to download student data, and then reads and summarizes the output using DT and ggplot2. Together, these tools demonstrate that R is not just a statistical environment but a viable end-to-end platform for course delivery and one that is especially well-suited to geography where interactivity and place-based context are essential. This workflow has been stress-tested across multiple courses and semesters with over 5,500 commits across five course repositories.

Speaker: Matthew Haffner (University of Wisconsin - Eau Claire)

R as Complete Teaching Infrastructure: Automating and Enriching University Geography Education

67 ApoBcomp: An R Shiny Framework for Apolipoprotein B Estimation and Cardiovascular Risk Modeling

Apolipoprotein B (ApoB) is a key biomarker reflecting the number of atherogenic lipoprotein particles and is increasingly recognized as a superior indicator of cardiovascular risk compared to traditional lipid measures. However, direct ApoB measurement is not always routinely available in clinical practice, and existing tools do not provide an integrated framework for its estimation and interpretation. We introduce ApoBcomp, an open-access R/Shiny-based web application designed to estimate ApoB levels and translate lipid profile data into clinically meaningful risk insights. The platform enables users to upload standard lipid panel data (total cholesterol, HDL-C, and triglycerides) and compute ApoB estimates using both established equations and supervised machine-learning (ML) models. A total of ten ML algorithms, including linear-regression, lasso, support vector regression, random-forest, and extreme gradient-boosting, were implemented. Model development incorporates grid-search hyperparameter optimization, repeated cross-validation, and external validation to ensure robustness and generalizability across diverse datasets. Beyond estimation, ApoBcomp integrates cardiovascular risk modeling modules aligned with major clinical guidelines, enabling classification of individuals into clinically actionable risk categories. This feature transforms raw lipid measurements into interpretable outputs that can support both research and clinical decision-making processes. The application is implemented in R using a modular Shiny architecture, supporting real-time computation, interactive exploration, and reproducible reporting. Users can upload data, perform analyses, and export results within a unified interface. The fully functional application is publicly available at: https://biotools.erciyes.edu.tr/ApoBcomp/. By bridging statistical-modeling, machine-learning, and clinical interpretation, ApoBcomp provides a scalable and reproducible platform for ApoB estimation and cardiovascular risk assessment within the R ecosystem.

Web Application: https://biotools.erciyes.edu.tr/ApoBcomp/
Funding: This work was supported by Research Fund of the Erciyes University (Project No: TYP-2025-14947).

Speaker: Ms Aleyna Erakcaoğlu (Department of Biostatistics, Erciyes University School of Medicine, Kayseri, Türkiye)

AErakcaoglu_presentation.pdf

Poster

68 Training and assessment of spatial prediction models: challenges, conceptual frameworks and implemented strategies in the R package CAST

One key task in environmental science is the continuous mapping of environmental variables across space, and often across both space and time. Machine learning algorithms are frequently employed for this purpose, combining local field observations with comprehensive sets of predictor variables to produce spatial predictions. This enables the prediction of the variable of interest at locations where measurements are unavailable. However, the application of machine learning strategies for spatial mapping involves additional challenges compared to ”non-spatial” prediction tasks that often originate from spatial autocorrelation and from training data that are not independent and identically distributed.

In the past few years, we have developed several methods to support the application of machine learning to spatial data. These include prediction-domain adaptive cross-validation for performance assessment and model selection, spatial predictor variable selection, and approaches to assess the area of applicability of trained models. The objective of the CAST package is to facilitate predictive mapping with machine learning by implementing these methods and making them easily accessible for integration into modeling workflows.

Here, we present the CAST package and its core functionalities, describing both its conceptual framework and practical applications. Using a plant species richness case study, we walk through the main steps of a modelling workflow and demonstrate how CAST can be used to support more reliable spatial predictions.

Speaker: Hanna Meyer (University of Münster)

CAST_V2.pdf

69 metasurvey: Reproducible Survey Data Processing with Step Pipelines in R

Household survey microdata is a primary input for social science research and public policy evaluation, yet the processing pipelines that turn raw microdata into publishable estimates are rarely documented, shared, or reproduced. Each research team writes ad hoc scripts to recode variables, construct indicators, and compute weighted statistics, duplicating effort and introducing silent inconsistencies across studies.

We present metasurvey, an open-source R package that provides a metaprogramming layer on top of the survey package for reproducible survey data processing. The package introduces three abstractions built on R6 classes: (1) Steps — lazy-evaluated transformations (compute, recode, filter, rename, remove, join, validate) that record their intent before execution; (2) Recipes — reusable, shareable collections of steps bundled with metadata and provenance tracking; and (3) Workflows — estimation routines (svymean,svytotal, svyby, plus convey inequality measures) that produce publication-ready tables with confidence intervals and quality indicators.

metasurvey handles complex sampling designs transparently, including rotating panels with bootstrap replicate weights and pooled multi-edition surveys. A built-in recipe registry with a REST API enables researchers to publish, discover, and reuse each other's processing pipelines. The package also includes a Stata .do file transpiler that converts legacy processing scripts into native metasurvey pipelines, lowering adoption barriers for teams transitioning from Stata.

The package is available on GitHub (github.com/metasurveyr/metasurvey) with over 2,700 tests, 90% code coverage, and comprehensive bilingual documentation. It has been validated against Uruguay's national household survey (ECH) across 40+ editions.

Speaker: Mauro Loprete (Universidad de la República, Uruguay)

metasurvey_useR2026-2.pdf

70 Flexible Aggregation with SUOWA Operators in R. An Implementation Based on the Choquet Integral

Aggregation functions play a central role in decision making, and among them, weighted means and Ordered Weighted Averaging (OWA) operators are two of the most widely used families. Their relevance is reinforced by the fact that both can be expressed as particular cases of the Choquet integral, which has inspired numerous attempts to develop unified generalizations of these operators.
Building on this line of research, the SUOWA and Semi-SUOWA operators provide flexible frameworks that retain key features of both weighted means and OWA operators, including the ability to assign customized weights and to modulate the influence of extreme values. However, despite the availability of R packages such as Kappalab and Rfmtool for computing discrete Choquet integrals, none offer dedicated tools for these specific operator families.
To address this need, we introduce WEMOWA, an R package developed to compute the capacities and Choquet integrals associated with SUOWA and Semi SUOWA operators. The package includes specialized functionalities for these generalizations and places particular emphasis on winsorized weighted means, an especially practical and relevant subclass within the SUOWA family. Our goal with WEMOWA is to support both applied decision making workflows and advanced methodological studies involving generalized aggregation operators

Speaker: Teresa Gonzalez-Arteaga (Universidad de Valladolod)

poster_SUOWA_109_94_imprimir.pdf

poster_SUOWA_109_94.pdf

71 A {ladder} to get on to the (Google) Slides

Google slides is a widely available productivity tool used by many institutions but is not well integrated with existing R ecosystem workflows such as Rmarkdown, which has made its use incompatible with reproducible research and reporting. ladder is an R package for inserting tables into Slides presentations and supports multiple table formats from R.

In particular it supports flextable objects, so can produce very nicely formatted tables, including headers and footers, merged cells, styled text, borders and highlighting.

It can be used interactively to dynamically insert/replace tables in a presentation or as part of a script for reproducible reporting.

Speaker: Isaac Gravestock (Roche)

ladder poster.pdf

72 rush: A Database-Centric Architecture for Distributed Computing in R

We present rush, an R package for asynchronous and decentralized optimization. Traditional approaches for parallel computing in R follow a controller-worker model where a central process proposes tasks, dispatches them to workers, and collects results. When proposing new tasks is computationally expensive, the central controller becomes a bottleneck that leaves workers idle, a problem that grows with the number of workers.

rush uses a database-centric architecture in which workers communicate through a shared Redis database and each runs its own optimization loop independently. The package provides a high-level API for managing tasks, featuring sub-millisecond per-task overhead, robust error handling with automatic detection of lost workers, and an efficient caching mechanism that minimizes database operations.

We developed rush to integrate with the mlr3 ecosystem and to serve as a backend for efficient Bayesian optimization. We demonstrate its practical utility by implementing asynchronous decentralized Bayesian optimization (ADBO) and benchmarking it on hyperparameter optimization of LightGBM across four datasets using 448 workers. ADBO achieves substantially higher CPU utilization across all tasks compared to traditional centralized Bayesian optimization approaches. By providing a framework for decentralized optimization in R, rush enables a class of algorithms previously available only in the Python ecosystem through frameworks like Optuna, DeepHyper, and Ray Tune.

Speaker: Mr Marc Becker (Ludwig-Maximilians-Universität München)

poster_2026_rush.pdf

73 Asking the Community: Interesting Queries and Everyday Challenges for the R Ecosystem

In the past months, we built a tool to analyze all versions (roughly 170,000) of all packages available on CRAN, obtaining around 80 GB of raw data on various semantic aspects such as call graphs of functions, dead code, values of constants, the coverage of provided vignettes, transitive dependencies of packages, and much more. Moreover, the data is linked to the release date and download numbers of these packages which allows exploring the evolution of these characteristics over time as well as weigh them by the adoption of the respective package.
Proposing the presentation of the results as a separate talk at useR 2026, we intend to use this poster to not only spark individual, more detailed discussions with members of the community, but also to collect a set of interesting questions and aspects to explore further.
Next to a summarized overview of the tool's architecture and data schema, the poster should feature a collection of insights obtained so far (such as the evolution of uncalled functions over time) and provide space for suggestions by the community in the form of post-it notes.
Please note, that the poster is self-contained and interaction is not dependent on the accompanying presentation.

Speaker: Florian Sihler (Ulm University)

poster.pdf

74 The Rbanism Community: Empowering Urbanists to Use Research Software Effectively and with Confidence

The Rbanism community aims to empower urbanism researchers, students, educators and practitioners to use open-source software and related open-science practices effectively and with confidence. It raises awareness, stimulates engagement and builds capacity by demonstrating the benefits of reproducibility, automation and scalability. Rbanism was initiated in 2021 by a group of R users in the Department of Urbanism at TU Delft, and it has since grown into an international community of 100+ members.

Our mission is to cultivate scientific computing, data science, computational thinking and software management skills for urbanism-related questions through peer exchange in a growing network. To that end, our activities include workshops on how to process and analyse geospatial data with R, many of which are held as part of the Carpentries, including the Geospatial Data Carpentry for Urbanism; GIS and mapping challenges such as the #30DayMapChallenge; and meetups. In addition to in-person activities, we organise online events open to our international community of urbanists. These various forms of engagement follow our commitment to inclusion and accessibility.

The Rbanism community has received support from the Netherlands eScience Centre, the Open Science Community Delft, and the TU Delft Library and Department of Urbanism.

Website: rbanism.org

Speaker: Claudiu Forgaci (Delft University of Technology)

rbanism-poster.pdf

75 Cross-Language Collaboration in Spatial Data Science: The SDSL Community

The Spatial Data Science across Languages (SDSL) Community brings together developers and users of common and emerging programming languages for spatial data science. It aims to foster understanding and address common issues while discussing language-specific problems. We focus broadly on geospatial and geographic space, with some applications to general image spaces and local reference frames ranging from microscopic to astronomical scales.

Open-source programming languages commonly used in spatial data science include R, Python, and Julia. Our community is also interested in JavaScript and TypeScript, C++ and Rust. These languages are used by millions of users daily to solve spatial problems. We face challenges beyond particular programming languages, such as the interpretation of underlying data, the representation of data in computers, visualisation, the scalability and efficiency of implementations, the use of upstream libraries such as GDAL, GEOS, and PROJ, GIS interfaces, software distribution, and open-source software community building. The r-spatial community is committed to investigating these cross-language challenges posed by SDSL.

Our main activity since 2023 has been a series of annual workshops organised across different parts of Europe that provide a space to bridge programming-language communities and establish cross-language interaction between developers and users. In 2026, we established the Lorena Abad Crespo Award for Innovation in Spatial Data Science, to be awarded annually to individuals who have made significant contributions to open spatial data science. It honours those who have pushed the boundaries of open source software for SDS and offered their ideas, transformed into tools, to the wider community.

Speaker: Claudiu Forgaci (Delft University of Technology)

sdsl-poster.pdf

76 City River Spaces (CRiSp): Automating and Scaling Up the Delineation of Urban River Spaces

Spatially designing and planning urban transformations around rivers while capturing the complexities of riverside urban areas remains challenging. An essential part of the challenge is how boundaries are drawn in the analysis of urban areas surrounding rivers. To overcome this challenge, we developed the rcrisp open-source R package to automate the morphological delineation of riverside urban areas—i.e., spaces where social, environmental and economic phenomena are assumed to be influenced by the presence of the river. Delineations following this method enable integrated local analyses, in which data from different sources must be combined within a neutral spatial unit, as well as global cross-case analyses, which require a spatial unit comparable across different geographic contexts.

The package includes functions to delineate the river valley, the river corridor, the corridor segments, and the river space (i.e., the area between the riverbanks and the first line of buildings) as well as an all-in-one function that runs all desired delineations. The resulting delineations can be used in any downstream analysis of riverside urban areas that benefit from consistent, comparable spatial units, including land-use, accessibility, and ecosystem services assessments. The package also includes functions to download and preprocess OpenStreetMap and global Digital Elevation Model data, which are required as input data for the delineation process.

With this poster, we aim to present the method, its implementation in rcrisp, and to demonstrate its broad applicability with use cases from different fields.

Speaker: Claudiu Forgaci (Delft University of Technology)

rcrisp-poster.pdf

77 Orchestrating the b3verse: Elevating Research Software through a Modular R Package Ecosystem

Scaling research software beyond single scripts or standalone packages requires deliberate architectural choices, shared conventions, and robust distribution infrastructure. This poster presents the b3verse, a coordinated ecosystem of twelve interoperable R packages designed to transform large biodiversity occurrence cubes into standardized indicators for research and policy support.

The ecosystem is built around a standardized occurrence cube data structure that serves as an explicit interface between packages. A gatekeeper validation function enforces structural consistency and harmonization of heterogeneous inputs, enabling seamless interoperability across specialized indicator packages such as pdindicatoR and impIndicator. The workflow spans data acquisition using rgbif, cube construction with b3gbi, exploratory analysis through dubicube, and indicator calculation with integrated bootstrap-based uncertainty estimation. Standardized interfaces ensure that alternative methodological implementations remain comparable while allowing independent package evolution.

To support cross-package development and onboarding, the ecosystem includes b3data, a dedicated frictionless data package providing shared, versioned example datasets. By distributing reference cubes and spatial grids in a consistent format, b3data enables reproducible testing, simplifies vignette development, and lowers the barrier for new contributors.

Continuous integration and cross-platform binary distribution are handled through R-Universe, simplifying installation while supporting coordinated releases across repositories. A shared software development guide defines testing practices, documentation standards, and conventions for data structures and function behaviour, providing a governance model for sustaining multi-package research software ecosystems in R.

Speaker: Ward Langeraert (Research Institute for Nature and Forest)

langeraert_user2026_b3verse_modular_ecosystem.pdf

78 pemr: A Unified R Interface for Managing Personal Exposure Monitor Data in Air Pollution Research

Air pollution exposure research relies on a growing diversity of wearable personal exposure monitors (PEMs), each producing log files with distinct header structures, column naming conventions, and measurement units. The R ecosystem already offers strong infrastructure at adjacent layers for network-level data (openair and AirSensor), on-road vehicle emission systems (pems.utils), and personal device-specific packages (e.g. rtimicropem and astr). However, a critical gap remains: no package provides a unified, device-agnostic interface for reading and harmonizing data from the multiple PEM types routinely deployed together within the same study for measuring personal exposure to air pollution.

pemr addresses this gap by implementing a consistent grammar for ingesting raw log files from heterogeneous PEM devices, such as the Enhanced Children's MicroPEM (ECM), Ultrasonic Personal Air Sampler (UPAS), and Particle and Temperature Sensor (PATS+). Rather than prescribing downstream analysis, pemr focuses on the upstream data management step: reading device-specific files and extracting harmonized time-series data through a unified interface. The package is designed around tidy data principles, integrating naturally into pipelines that process study metadata alongside measurement data.

This design is particularly relevant for multi-country field trials and cohort studies where investigators simultaneously deploy two or more PEM types across participant groups. In these settings, harmonized ingestion reduces the per-device boilerplate that currently forces analysts to maintain parallel, device-specific reading scripts. pemr provides clean, structured dataframes needed for downstream work in any analytical pipeline. Future development aims to expand device support and formalize a common data model for PEM output.

Speaker: Dr Oscar de Leon (Universidad del Valle de Guatemala)

pemr-poster.html

pemr-poster-v3.pdf

79 An LLM-based Pipeline for Understanding Decision Choices in Data Analysis from Published Literature

Decision choices, such as those made when building regression models, and their rationale are essential for interpreting results and understanding uncertainty in an analysis. However, these decisions are rarely studied because tracing every alternatives considered by authors is often impractical, and reworking a completed analysis is generally of limited interest. Consequently, researchers must manually review large bodies of published analyses to identify common choices and understand how choices are made. In this work, we propose a workflow to automatically extract analytic decisions and their reasons from published literature using Large Language Models. Our method also introduces a paper similarity measure based on decision similarity and visualization methods using clustering algorithms. As an example, this workflow is applied to analyses studying the effect of particulate matter on mortality. This approach enables scalable and automated studies of decision choices in applied data analysis, providing an alternative to existing qualitative and interview-based studies.

Speaker: H. Sherry Zhang (University of Texas at Austin)

useR-poster.pdf

80 deltatest: Statistical Hypothesis Testing Using the Delta Method for Online A/B Testing

Online A/B tests often randomize at the user level while evaluating ratio metrics at a finer-grained unit, such as page views or sessions. This mismatch induces within-user correlation and can make standard Z-tests anti-conservative, increasing false positives. The deltatest package provides an R interface for delta-method-based hypothesis testing of ratio metrics, following the practical approach described by Deng et al. (2018). The package is available on CRAN and is designed for lightweight use in R-based experimentation workflows.

Users provide data aggregated at the randomization unit (e.g., user-level clicks and page views), specify the metric using a concise formula interface, and obtain familiar htest-style results, including estimates, confidence intervals, and p-values. The package supports multiple input styles (standard formulas, lambda formulas, and non-standard evaluation) and can test both absolute differences and relative changes.

This poster introduces the statistical motivation for delta-method variance correction in online experiments, explains the required data structure, and demonstrates practical usage of deltatest with reproducible examples. We will also present simulation-based illustrations showing how ignoring within-user correlation can distort null p-value distributions and how the delta-method approach improves inferential reliability. The goal is to help R users conduct more trustworthy analyses of online experiments with a transparent, package-native workflow.

Speakers: Daisuke Ichikawa (Kibaroku), Koji Makiyama (HOXO-M Inc.), Shinichi Takayanagi, kazuyuki sano

deltatest.pdf

81 Statistical Analysis and Predictive Modeling of IPL Match Data Using R

The increasing availability of structured sports datasets has created new opportunities for applying statistical analysis and predictive modeling techniques to sports analytics. The Indian Premier League (IPL) provides detailed match and ball-by-ball datasets that allow in-depth statistical exploration of match dynamics and performance patterns. This study applies statistical analysis and visualization techniques in the R programming environment to analyze scoring patterns, evaluate strategic factors influencing match outcomes, and develop predictive models using historical IPL data.

Exploratory analysis is first conducted to examine run distribution across overs in order to understand scoring behavior during different phases of an innings such as the powerplay, middle overs, and death overs. Visualizations generated using ggplot2 highlight how scoring rates evolve throughout an innings and how teams accelerate scoring during the final overs.

Venue-based analysis is also performed to compute average runs scored at different stadiums, allowing comparison of scoring patterns across venues. A chi-square hypothesis test is conducted to evaluate whether winning the toss significantly affects the probability of winning a match.

Finally, a logistic regression model is developed to predict match outcomes using variables such as competing teams, venue, toss winner, and first innings score. The project demonstrates how the R ecosystem enables effective statistical analysis, reproducible workflows, and predictive modeling for sports data analytics.

Speaker: Vihan Singh (Indian Institute of Information Technology Una)

MLMatchPredictorPSV.mp4

Statistical Analysis and Predictive Modeling of IPL Match.pdf

Statistical Analysis and Predictive Modeling of IPL Match.pptx

useR_poster.pptx

82 Analyzing Global Music Trends Using Spotify Audio Features: A Data-Driven Analysis in R

The widespread adoption of digital music streaming platforms has created unprecedented opportunities to analyze large-scale music consumption data. This study investigates global music trends by analyzing Spotify track data using statistical and visualization techniques implemented in R. The objective is to explore how various audio features—including danceability, energy, valence, acousticness, and tempo—relate to song popularity and how these characteristics have evolved across different release periods.

The analysis utilizes a publicly available Spotify tracks dataset and follows a structured data analytics workflow consisting of data preprocessing, exploratory data analysis, correlation analysis, and feature-based trend visualization. Using R packages such as tidyverse, ggplot2, and dplyr, the study examines relationships between musical attributes and listener engagement while identifying patterns that characterize highly popular tracks.

Visual analytics techniques are employed to reveal temporal changes in audio feature distributions and highlight potential associations between musical structure and audience preferences. Preliminary findings suggest that certain combinations of audio attributes—particularly higher energy and danceability levels—are frequently associated with increased popularity, indicating evolving stylistic preferences in contemporary music production.

This work demonstrates the effectiveness of R as a flexible platform for large-scale music data analysis and illustrates how data mining and visualization methods can provide valuable insights into modern music consumption patterns. The findings contribute to a broader understanding of how data-driven approaches can be applied to analyze trends in the digital music ecosystem.

Speaker: shristi y (IIIT UNA)

Shristi_useR2026_Spotify_Poster.pdf

shristi_user_R_presentation.mp4

83 **md2qstn** : An R Package for Reproducible Survey Design and Lifecycle Management

The purpose of this talk is to present md2qstn, a specialized R library developed to bridge the gap between plain-text survey drafting and digital deployment. md2qstn enables the conversion of Markdown-formatted questionnaires into DDI(Data Documentation Initiative)-compliant XML and Qualtrics-compatible QSF(Qualtrics Survey Format) JSON files. Although the prevailing approach in social research involves the use of browser-based GUIs, such methods lack the scalability and efficiency required for complex or iterative survey development. By adopting Markdown as a foundational format, md2qstn mitigates the inefficiencies associated with manual web UI entries. The suite of functions within md2qstn offers social scientists a platform for reproducible survey design, effectively integrating the survey data lifecycle into a seamless R-based workflow.

Speaker: Yasuto NAKANO (Kwansei Gakuin University)

useR2026_Warszawa_nakano.pdf

Wednesday 8 July

08:00 Registration open

08:30 Coffee Break

Keynote: A world still to be mapped: reflections on geocomputation in R

Conveners: Jakub Nowosad, Kevin Patrick O'Brien

84 A world still to be mapped: reflections on geocomputation in R

Abstract:

Spatial data are central to understanding environmental change, social processes, and their interactions. Maps are not only visual products of analysis, but tools that shape how problems are framed, how phenomena are perceived, and how decisions are made. R has become a widely used environment for spatial data science because it combines interactive analysis, open development, statistical rigor, and strong visualization within reproducible workflows.

This keynote will review the current state of spatial work in R, highlighting mature and interoperable tools, intuitive workflows, and available documentation and learning resources -- developments that support reliable and integrative spatial analysis across disciplines. It will then turn to what is still missing, pointing to methodological, technical, and community challenges that limit what can currently be done.
The keynote will also reflect on both the potential and the limits of current approaches, and on what they depend on in practice, including the availability of high-quality data and domain knowledge.

It will conclude by discussing how spatial methods act as integrators across fields, shifting the focus from tools to problems, and by considering how education, open-source practice, and emerging computational approaches may shape the future of spatial data analysis in R.

Bio:

Jakub Nowosad is an associate professor at Adam Mickiewicz University in Poznań and a visiting scientist at the University of Münster. He is a computational geographer working at the intersection of geocomputation and environmental science, where he develops spatial methods to understand complex environmental and ecological patterns and processes. He is a co-author of the Geocomputation with R book and an active contributor to the #rspatial and open-source geospatial communities. He works to make spatial data analysis more accessible and impactful for people working with spatial data.

Speaker: Jakub Nowosad

index.html

Slides

10:00 Coffee Break

Talks: Building tools for reproducible research

Convener: Sebastian Meyer (Friedrich-Alexander-Universität Erlangen-Nürnberg)

85 Practical Strategies for R-Based Research in Secure Data Environments

In social science research, datasets are often confidential, requiring analyses to be conducted in secure remote access environments. One such environment is FIONA, which provides researchers with access to sensitive, unit-level Finnish register data alongside standard statistical software, including R. We use FIONA to analyse extensive register data on Finnish teenagers and young adults, with a substantive focus on deaths of despair, including suicide, overdoses, and violence.

R is a natural choice due to its open-source ecosystem and flexibility, which support tool development within FIONA despite the constraints of a closed environment. However, constraints such as limited computational resources, restrict model complexity and require careful workflow planning. While basic models can be fitted in reasonable time, more demanding approaches can become infeasible. Memory constraints further necessitate careful handling of large datasets and intermediate outputs. Additionally, fixed CRAN snapshots may limit access to recent or non-CRAN packages, requiring alternative tools.

We discuss practical strategies for addressing these constraints, including staged model development starting from simple specifications, careful management of intermediate results, and theory-driven variable selection to reduce unnecessary computation. We also describe the use of parallel computing tools to speed up analyses where feasible.

Reproducibility and openness raise important challenges in secure environments. Although the data cannot be shared, we aim to publish full analysis code, model specifications, and detailed data descriptions.

Overall, the presentation provides concrete recommendations for conducting reproducible and efficient R-based research in secure environments, while highlighting limitations that should inform the future development of such infrastructures.

Speaker: Aleksi Lahtinen (University of Turku)

Lahtinen_useR2026_slides.pdf

86 Critical Paths in R: Turning Data Scientists into Effective Project Managers

Many data scientists and other R users have no doubt been assigned to projects that quickly derailed—missed deadlines, scope creep, budget overruns—often because effective project management was assumed to be a "soft skill" anyone without deep technical expertise could handle. In reality, successful project delivery demands rigorous quantitative techniques: structured decomposition, dependency-aware scheduling, probabilistic risk assessment, and data-driven compression strategies. These are not just "management" tasks—they are applied statistics and operations research problems ideally suited to R.
At some point in their careers, many R users (maybe most) will be asked to lead a project—whether it’s delivering a predictive model pipeline, coordinating a research initiative, building a dashboard for stakeholders, or driving a cross-functional analytics effort. Dedicated project managers from a PMO may not always be available. Or individuals may choose to take ownership to expand their skill set, demonstrate leadership beyond coding, and show they can deliver end-to-end value rather than remain single-level contributors.
The good news is that any project can be planned and managed entirely within the R ecosystem. No need to learn Microsoft Project, Primavera, or some other project management software. With base R and packages like crtipath and ggplot2, users can build and manage projects reproducibly and quantitatively--right where they are otherwise ingesting, manipulating, and analyzing data.
My talk will demonstrate how to build a proper work breakdown structure (WBS), how to apply best project management practices to estimate task durations, how to identify the critical path that makes or breaks project success, how to calculate the precise probability of on-time completion, and how to evaluate where-and by how much-to crash critical activities to improve the probability of on-time completion-using many techniques attendees have no doubt applied to other domains.
Attendees will leave with ready-to-adapt code snippets that turn project management into a reproducible extension of their analytical work—empowering them to own project success without external tools or fragmented workflows.

Speaker: Gary Sutton

useR.pptx

87 Managing Analytic Multiplicity in Epidemiology: Reproducible Multiverse and Vibration of Effects Analyses in R

Empirical data analysis often involves a large number of defensible analytic choices, including model specification, covariate selection, transformations, and approaches to missing data. These decisions can meaningfully influence statistical results, yet they are rarely explored or reported systematically. This talk presents a reproducible R-based workflow for examining analytic multiplicity using multiverse analyses and vibration of effects frameworks. The approach is motivated by the author's ongoing research on trustworthy data analysis and practical challenges encountered in large observational epidemiological studies. Using R, analysts can enumerate plausible analytic specifications, run large sets of models programmatically, and summarize the resulting distribution of estimates rather than relying on a single analytic pathway. This presentation aims to demonstrate how tidyverse pipelines, reproducible project structures, and modern visualization tools can be used to explore and communicate how results vary across reasonable modeling decisions. Examples from applied epidemiology and public health will illustrate how alternative analytic choices can produce substantially different effect estimates even when each specification is methodologically defensible. Emphasis will be placed on practical implementation in R, computational efficiency, and clear communication of analytic uncertainty. By making analytic decision spaces visible and reproducible, multiverse and vibration of effects approaches allow researchers to assess the robustness of empirical findings and strengthen transparency in statistical reporting.

Speaker: Alyssa Columbus

Columbus_useR2026_Analytic_Multiplicity.pdf

GitHub Repository

88 Towards Reproducible Research using NHANES Data

The National Health and Nutrition Examination Survey (NHANES) provides extensive public data on demographics, health, and nutrition, collected in two-year cycles since 1999. Although invaluable for epidemiological and health-related research, the complexity of NHANES data makes accessing, managing, and analyzing these datasets challenging. We present a reproducible computational environment built upon Docker containers, PostgreSQL databases, and R/RStudio, designed to streamline NHANES data management, facilitate rigorous quality control, and simplify analyses across multiple survey cycles. We envision this effort as part of the broader Epiconnector project, which aims to foster collaborative sharing of code, analytical scripts, and best practices, which taken together can significantly enhance the reproducibility, extensibility, and robustness of scientific research using NHANES data.

Speaker: Robert Gentleman (Dana-Farber Cancer Institute)

Talks: Environmental sciences

Convener: Hanna Meyer (University of Münster)

89 Modernizing R's web-mapping capabilities

When it comes to web-mapping in R, RStudio’s (Posit’s) 'leaflet' package has established itself as the de-facto standard. However, in addition to the lack of support for 3D data, 'leaflet' struggles with the rendering of large data (i.e. more than 1 million points/vertices) and data transfer from R memory to the browser can be slow. To overcome these bottlenecks, two packages, 'geoarrowWidget' and 'geoarrowDeckglLayers' will be presented. The former leverages Apache (Geo)Arrow instead of GeoJSON for fast data transfer from R to the browser, while the latter, a new add-on package for 'mapgl', utilizes '@geoarrow/deck.gl-layers', a performant JavaScript library to enable quick overlays on web-maps based on 'Deck.gl'. 'Deck.gl' is a WebGL based geo-spatial rendering platform for the browser that provides GPU-accelerated graphics, allowing performant visualization of large geo-spatial data. Another focus of the developments presented in this talk is to enable the visualization of modern cloud-native geo-spatial data, such as 'GeoParquet' directly from remote URLs, bypassing the need to read data into R memory. This allows styling instructions to be defined in R which are transferred to the browser and then being applied to the incoming data when it arrives from the remote URL.

This development is made possible with a grant from the R-Consortium.

Speaker: Tim Appelhans (Friedrich-Alexander Universität Erlangen-Nürnberg, Institut für Geographie, Wetterkreuz 15, 91058 Erlangen, Germany)

modernizing_r_webmapping.html

90 Areal interpolation methods

Areal units (polygons or pixels) are often used to summarize and distribute spatial data. In many spatial data science studies, datasets with different areal units need to be combined, and to do so first have to be transformed into a common set of areal units. This involves upscaling (going to a coarser resolution) or downscaling (going to a finer spatial resolution), or a combination. This presentation will explain the problem, review purely geometrical approaches (area-weighted interpolation, dasymetric mapping) and geostatistical approaches (area-to-area kriging), and discuss implementations in R.

Speaker: Edzer Pebesma (University of Münster)

Areal Interpolation Methods

Areal Interpolation Methods (1).pdf

91 Is here still where it was? Changes in terrestrial reference frames in R spatial packages

When we represent or analyse spatial data, the position of observations matters. Where objects of interest are, also in relation to each other, and how position is measured, are referenced through coordinate reference systems (CRS), including units of measurement. Local CRS use arbitrary starting points, while standard CRS rely on tabulated values, for example the axis lengths of an ellipsoid representing the Earth.

The R geospatial cluster of contributed packages are largely built on the foundation of Open Source libraries and ancilliary data, including GDAL, PROJ, and through proj.db, the EPSG tabulations of definitions and values used to represent position. Crucially, the tabulations include coordinate transformations from one CRS to another.

The Earth's tectonic plates are not static bodies, but have often been treated as as such. Much positional data is taken as defined by the World Geodetic System of 1984 (WGS84), without stating which realisation is applied (WGS84 is a datum ensemble); in North America, NAD83 is often treated like this, and the same applies elsewhere. At present, standards in Europe and North America are being upgraded to accommodate movements in three dimensions of tectonic plates, and their stretching and bending. New standards are entering the EPSG database, so through PROJ and GDAL, enter R workflows. As this happens, the same coordinate transformation may yield different results, depending on the CRS definition and EPSG version. We need to be ready for these changes when they become relevant, and this submission will show how this may be achieved.

Speaker: Roger Bivand (Norwegian School of Economics)

bivand_useR26_pres2.pdf

92 Introduction to edgeTransport: developing sustainable transportation futures

Scenario analysis lets us explore ‘what-if’ futures for climate change, linking today’s decisions to long-term impacts. Systematic comparison of scenarios for transport – a key sector for emission reductions – can inform decision-making in policy and investments. Decarbonization of passenger and freight transport depends on mode shifts and the adoption of low-carbon technologies like electric vehicles (EVs). The model edgeTransport is a representation of the global transport sector with high technological and modal detail and allowing for these kinds of analyses. edgeTransport - combining R packages mrtransport, edgeTransport edgeTransport and reporttransport - is open-source with closed data dependencies for parameter calibration. Coupling edgeTransport to the global energy-economy-climate model REMIND further adds an integrated systems perspective. REMIND is one of the leading integrated assessment models regularly informing global climate policy making, for example by contributing to reports from the Intergovernmental Panel on Climate Change (IPCC). For these contributions, REMIND relies on the sectoral detail provided by edgeTransport. Coupling the models enables both, high detail and a full systems perspective. This revealins cross-sectoral effects and important correlations, for example how reducing grid carbon intensity is integral to EV-based decarbonization strategies.
In this talk, I will introduce the model ecosystem and its main features and limitations, illustrate analysis and development workflows, show how to get involved and demonstrate three scenarios: our ‘business as usual’ baseline scenario (current policies) and two higher-ambition sustainability scenarios.

Speaker: Alex K. Hagen (Potsdam Institute for Climate Impact Research (PIK))

2026-07_useR_sustainableTransportationFutures_HagenV2.pdf

Talks: Statistical models and methods

Convener: Maciej Romaniuk (Systems Research Institute, PAS)

93 stats::free1way(): Semiparametrically Efficient Population and Permutation Inference in Distribution-free Stratified K-sample Oneway Layouts

Starting with R 4.6-0, the stats package provides infrastructure for distribution-free model-based inference in possibly stratified K-sample oneway layouts via the novel free1way model function. Treatment effects to be estimated using free1way include odds- and hazard ratios, Lehmann parameters, and a generalised version of Cohen's d for at least ordered and possibly right-censored outcomes.

In addition to nonparametric maximum-likelhood estimators of treatment effects, the procedure allows Wald, Rao score, and likelihood ratio tests with corresponding confidence intervals to be computed. Asymptotic and approximate Monte-Carlo-based permutation tests and confidence intervals are also available. In proportional odds models, exact permutation inference is implemented based on exact permutation distributions derived via the Streitberg-Röhmel algorithm.

Graphical tools for model diagnostics, including model-based confidence bands for receiver operating characteristic (ROC) curves in probability-probability plots in the new ppplot function, allow data-driven criticism of model assumptions.

Power assessment and sample-size planning is facilitated either in a simulation-based way relying on random number generation via rfree1way or based on approximations of the information matrix power.free1way.test, the latter approach being much faster but slightly less accurate.

The new free1way function can be understood as a unification and generalisation of some of the classical ``nonparametric'' test procedures in stats, including kruskal.test, wilcox.test, friedman.test, mantelhaen.test, prop.test, mcnemar.test, as well as power.prop.test, allowing the magnitude of treatment effects to be interpreted on various scales, providing the possibility to assessment variability by means of confidence intervals and corresponding
tests for these parameters, and offering tools for sample-size planning and model criticism.

We will discuss how the new functionality helps to improve statistical inference.

Speaker: Torsten Hothorn (CH/DE)

slides_free1way.pdf

94 An Enhanced Projection Pursuit Tree Classifier with Visual Methods for Assessing Algorithmic Improvements

This talk presents enhancements to the projection pursuit tree classifier and visual diagnostic methods for assessing their impact in high dimensions. The original algorithm uses linear combinations of variables in a tree structure where depth is constrained to be less than the number of classes, a limitation that proves too rigid for complex classification problems. Our extensions improve performance in multi-class settings with unequal variance-covariance structures and nonlinear class separations by allowing more splits and more flexible class groupings in the projection pursuit computation. Proposing algorithmic improvements is straightforward; demonstrating their actual utility is not. We therefore develop two visual diagnostic approaches to verify that the enhancements perform as intended. Using high-dimensional visualization techniques, we examine model fits on benchmark datasets to assess whether the algorithm behaves as theorized. An interactive web application enables users to explore the behavior of both the original and enhanced classifiers under controlled scenarios. The enhancements are implemented in the R package PPtreeExt, which is available on CRAN.

Speaker: Natalia da Silva (Universidad de la República)

PPtreeExt_UseR.pdf

95 R Package VIM: Flexible Model Adaptive Imputation with Vimpute

Handling missing values in heterogeneous datasets remains a common challenge in applied data analysis. We introduce vimpute(), a new function in the R package VIM that provides a unified and model-adaptive framework for multivariate imputation. The function implements an iterative, variable-wise imputation procedure that adapts the modelling strategy to the type and characteristics of each variable, while allowing users to flexibly specify the imputation models.
vimpute() is designed as a flexible and extensible interface built on the mlr3 ecosystem, enabling the use of a wide range of modern learning algorithms, including Random Forests, XGBoost, regularized models, and robust regression methods. Numerical variables can optionally be imputed using predictive mean matching with configurable neighborhood sizes and matching strategies. This design allows users to combine model-based imputation with machine-learning methods within a single workflow.
The imputation procedure follows a sequential updating scheme with convergence diagnostics to assess stability. Optional hyperparameter tuning can be performed via mlr3, allowing automated model configuration while maintaining transparent and reproducible workflows.
Simulation experiments and applications to real-world datasets demonstrate that vimpute() provides robust and statistically valid imputations across diverse data settings. By combining methodological flexibility with tight integration into the modern R machine-learning ecosystem, vimpute() supports reproducible and scalable missing-data workflows for applied research, official statistics, and data science applications.

Speaker: Eileen Vattheuer (Statistics Austria)

vimpute_vattheuer.pptx

96 A Connected Set of R packages for Regularized Regression based on Ridge and S-Type Estimators

The subject of this presentation concerns the implementation of regularized regression and advanced parameter estimation procedures. The study demonstrates the practical application of these methods using three R packages developed by the authors: S-type.est, Styperidge.reg, and ridgregextra.

Within this ecosystem, the S-type.est package provides the core estimation procedures for S-type estimators, serving as the methodological foundation. The Styperidge.reg package implements S-type regularized models for classical linear regression settings, while ridgregextra focuses on ridge regression as a special case, offering extended tools for estimation and diagnostic analysis.

To showcase the utility of these packages in complex data environments, we present a case study on energy demand prediction. Energy forecasting often involves high-dimensional, highly correlated predictors—such as meteorological variables and historical consumption patterns—where standard OLS estimators frequently fail. The combined use of these packages enables a comprehensive examination of ridge and S-type regularization, emphasizing usability, reproducibility, and methodological clarity in addressing the challenges of energy-related statistical research.

Speakers: Dr Filiz Karadag (Ege University), Dr Olgun Aydin (Gdansk University of Technology)

presentation_useR2026_v4.pptx

Talks: Web applications (Shiny, dashboards)

Convener: Simon Urbanek

97 {teal}: A production-ready modular framework for reproducible data exploration on clinical trials

In data-intensive industries like pharmaceuticals, the ability to move seamlessly from population-level summaries to individual data points is critical for valid insight generation. However, enabling faster, more efficient exploratory analysis and regulatory delivery of clinical trials insights is challenging and difficult to scale. This talk introduces {teal}, recently released on CRAN with the first major version, designed to build highly flexible, modular Shiny applications for exploratory data analysis.

We will explore the technical architecture of {teal}, focusing on how it leverages a "module-of-modules" approach to allow app-developers to assemble complex interfaces from reusable components. By abstracting the UI, data filtering logic, and reporting, {teal} allows developers to focus on analysis content rather than application boilerplate. Beyond interactivity, we will discuss how the reproducibility of any state of the interactive analysis is guaranteed by the reporting feature that captures and exports interactive findings into reproducible documents.

We will conclude with lessons learned from piloting these modules in large-scale clinical environments and discuss the framework's extensibility to other domains requiring rigorous, interactive data review for preparing it for the future.

Speaker: Dr Lluís Revilla Sancho (Roche, Spain)

Lluis_Revilla_teal_useR2026.pptx

98 Building stateful web apps with Rserve

Web front-ends offer seamless deployment across desktop and mobile platforms, with an ever growing variety of libraries enabling rich, interactive user experiences. However, integrating these modern web technologies with R's powerful analytic capabilities presents significant challenges.

Rserve is an R library that enables two-way communication between R and other programming environments, including TypeScript. While tools like ReactJS excel at building interactive interfaces, combining them with R for data processing and analysis is not straightforward. Three primary challenges emerge when using Rserve in web applications: implementing type safety for a native TypeScript developer experience; managing complex application architecture, particularly with hierarchical and conditional features; and synchronising application state between the front-end and R backend.

To address these challenges, I have developed a suite of software packages that simplify building stateful web applications with Rserve. The rserve-ts package provides a modern TypeScript library with a fully typed and modernised API for interacting with Rserve, ensuring type safety throughout the development process. RserveTS enables R users to write R functions and design stateful widgets that integrate seamlessly into web applications. The react-rserve package provides React hooks that deliver a native React developer experience.

In this talk, I will introduce these packages and demonstrate how they can be used to build complex, data driven web applications powered by R.

Speaker: Tom Elliott (iNZight Analytics Ltd)

Building stateful web apps with Rserve

99 Plumbing Your Way to React: Using Plumber APIs to Evolve Shiny Systems

In 2024, I talked about How I Built An API for My Life (and How You Can Too) which was a personal life tracker, called Hrafnagud, built using a slew of services but primarily with the support of R, namely, {plumber} and {shiny}. This was an API with a chunk of different endpoints for finance, travel, and more. The key focus was building the first iteration of such a system, and as the system matured, I learned that a good path for an R developer is to decouple R the backend and R the fronted.

In this talk, which is a spiritual sequel, I will discuss about what happens after the API exists, and where do you go from there. With maturity, a system tends to outgrow UI-centric platforms, not that it has to, but there is a natural progression to it all. The purpose is not to discourage you from using Shiny but looking beyond it, if and when necessary, and to empower teams to embrace several technologies where {plumber}, and {plumber2}, act as a narrative glue between different ways to consume APIs. I will also talk about the least disruptive rewrite, using LLM-based APIs, and how React can help enable an extensive and multi-modal way to consume an API that still uses R on the backend.

For a viewer, they would take away inspiration as well as systems-level thinking that empowers them to break beyond their comfort zone to embrace solutions that work for them, combine them in wonderful ways, and build something that truly lasts: as much as the ephemeral nature of software allows, of course.

Speaker: Deepansh Khurana (Dimwit Labs)

GitHub Repo

Google Slides (alternative)

Plumbing Your Way to React_ Using Plumber APIs to Evolve Shiny Systems.pptx

100 CRDTs for R: Conflict-Free Data Structures for Real-Time Collaboration

Collaborative data analysis presents a fundamental concurrency problem: when multiple users modify the same data simultaneously, how should conflicts be resolved? Traditional approaches rely on locking or central arbitration, but conflict-free replicated data types (CRDTs) offer a principled alternative. A CRDT is a data structure whose concurrent operations are guaranteed to converge to the same state, regardless of the order in which they are applied. This mathematical property — strong eventual consistency — eliminates the need for conflict resolution logic entirely.

We introduce CRDTs to the R ecosystem through automerge, an open-source package developed at Posit that natively bridges R's data model with the Automerge Rust CRDT engine. Collaborative documents — maps, lists, and text — appear as familiar R objects, but every edit is tracked as an individual operation under the hood. When documents are modified concurrently, changes merge automatically.

Beyond real-time document editing, CRDTs open up new possibilities for the R ecosystem: shared annotation of datasets across a research team, collaborative model specification, or any workflow where multiple analysts need to work on the same objects without coordination overhead. We make this concrete with a live demonstration: audience members will open a Shiny application on their own devices and edit shared state together, watching changes from every participant merge seamlessly in real time.

Speaker: Charlie Gao (Posit Software, PBC)

CRDTs for R: Conflict-Free Data Structures for Real-Time Collaboration

Lightning Talks

Convener: Maciej Romaniuk (Systems Research Institute, PAS)

101 automatedRecLin: Record Linkage Based on an Entropy-Maximizing Classifier

In this paper, we present the automatedRecLin R package (available on CRAN), designed to perform record linkage based on an entropy-maximizing classifier. First, we briefly introduce the maximum entropy classification algorithm for record linkage, originally proposed by Lee et al. (2022, Surv. Methodol.), and describe an extension that allows for the use of continuous comparison functions. In a simulation study, we demonstrate that the package's methods yield low error rates and satisfactory estimates of the number of matches. Then, we show how to use the automatedRecLin package in both supervised and unsupervised settings. We focus on switching between different estimation methods, incorporating custom comparison functions, and selecting approaches for creating a set of predicted matches. We conclude with a case study demonstrating a complete workflow for record linkage with the automatedRecLin package.

Speaker: Adam Struzik (Adam Mickiewicz University in Poznań)

struzik-beresewicz-user-2026.html

Lightning Talks

Convener: Sebastian Meyer (Friedrich-Alexander-Universität Erlangen-Nürnberg)

102 flowR: A Dataflow Analysis Framework and Program Slicer for R

R provides a plethora of packages and features that support the dynamic and interactive exploration of data.
Yet, there is a lack of static analysis tools which support program comprehension, reproducibility, and software engineering practices.
With flowR we provide not just a static analysis framework, but also an easily accessible extension for common IDEs such as Visual Studio Code, RStudio, and Positron (links point to the respective instances).
In this talk, we present a brief summary of the extensions and their features, focusing on how they can support R developers in their work.
FlowR provides an overview of a given data analysis, an integrated linter for reproducibility smells, and hover-over tooltips providing shape information for involved data frames.
Moreover flowR also includes a program slicer, which either 1) reduces a program to only the parts relevant to a certain variable of interest like a visualization or a statistical test in the form of a backward slice, or 2) shows the impact of, for example, a given import by reducing the program to just the parts relying on that import.
In the real-world, we observe huge reductions of the program size by slicing, often by more than 90%, which can be a huge help for program comprehension and reproducibility.
We also hope to get feedback from the R community on how these features can be further improved and integrated into their workflows.

flowR has been featured prior at ASE '24 and OOPSLA '25.

Speaker: Florian Sihler (Ulm University)

noanim-presentation.pdf

presentation.pdf

103 Streamlining reproducible research with `checklist`: new organisation management and enhanced quality control

The checklist R package has undergone significant evolution, with a major focus on flexible organisation management and improved quality control workflows.
The most substantial change is the introduction of the org_list and org_item classes (v0.5.0), which supersede the previous organisation class.
This redesign enables research groups to define and enforce their own institutional requirements.
The new system can enforce an Research Organization Registry (ROR) and license requirements for specific organisations and ORCID identifiers for their members.
new_org_list() helps you to create these custom organisation profiles interactively, with get_default_org_list() automatically detecting the appropriate profile based on git remotes.

Additional enhancements include improved Zenodo integration with publisher information and EU grant IDs for better research tracking, expanded support for renv-based reproducible environments in GitHub Actions, and enhanced quarto compatibility.
The package now handles author affiliations with multiple institutional memberships and provides create_draft_pr() for streamlined GitHub collaboration workflows.

Quality control has been strengthened through check_cran() displaying full test outputs, automatic dependency installation in CI/CD pipelines, and better handling of git configuration issues.

Please visit the checklist website to find the help files, vignettes and installation instructions.

Speaker: Thierry Onkelinx (Research Institute for Nature and Forest (INBO))

onkelinx_2026_checklist.html

Lightning Talks

Convener: Simon Urbanek

104 Moving data computation to web browser with 'jsplyr'

The presentation will introduce jsplyr, a new and experimental R package providing a dplyr interface for lazy-evaluated data manipulation in JavaScript. The package is designed to offload heavy data calculations from the server to the web browser, making it particularly useful in shiny applications.

The talk will begin with the rationale behind creating jsplyr and its current experimental nature. Next, the package's architecture and concept will be explored in greater detail, highlighting similarities and differences to dbplyr. While jsplyr employs logic analogous to dbplyr - storing and evaluating data manipulation queries lazily - it operates in the web browser rather than a database context. Unique challenges and benefits of this approach will be discussed, especially in the realm of shiny.

One key distinction between jsplyr and other dplyr-based packages lies in its handling of reactive contexts. To collect() the output within shiny, users must place this verb in a separate reactive wrapper, allowing the application to validate inputs appropriately.

A demo of a shiny app powered by jsplyr will accompany the presentation, illustrating real-world uses. To conclude, the roadmap for jsplyr will be outlined, including adding support for verbs like mutate(), group_by(), and summarise(), improving data flows within reactive contexts, and more closely aligning with the tidyverse architecture.

Speaker: Maciej Banas

jsplyr UseR 2026.pptx

105 Deploying Shiny Apps on Google Cloud Run

This talk presents a practical workflow for taking a Shiny app from local development to a public production deployment using Google Cloud Run. Drawing on the deployment of a real dashboard, I show how to package a Shiny app in a container, deploy it as a managed web service, connect it to a custom domain, and update it through a lightweight GitHub based workflow.

Rather than treating deployment as a purely technical afterthought, the talk focuses on the choices that matter for R users who want to publish dashboards that are reproducible, scalable, and maintainable without adopting a full platform engineering stack. I discuss where Cloud Run fits relative to more familiar Shiny hosting options, what configuration steps created the most confusion in practice, and what tradeoffs arise around simplicity, cost, and control.

The aim is to give R users a clear mental model and a concrete starting point for deploying public facing Shiny applications in a flexible cloud environment. The workflow is especially relevant for researchers, analysts, and small teams who want a flexible route to production while staying close to the tools they already use.

Speaker: Alfredo Hernandez Sanchez (Vilnius University)

Deploy R Shiny Apps with Google Cloud Run

12:00 Lunch

Panel discussion: Digital Sovereignty Through Open Source in Data Science

Conveners: Dianne Cook (Monash University, Australia), Dominik Batorski (University of Warsaw), Laia Domenech-Burin (Sovereign Tech Agency), Marcin Dubel (Appsilon), María Cristina Nanton (University of Buenos Aires | Health Information and Statistics Office of the City of Buenos Aires), Simon Urbanek (R Foundation)

Talks: Efficient programming

Convener: Filiz Karadag (Ege University)

106 Growable Vectors and In-Place Row Operations: A data.table Perspective

R’s copy-on-modify semantics make repeated growth and row-wise operations appear inherently expensive. Appending rows or incrementally building tabular structures typically triggers reallocation and copying. Recent versions of R now introduce an experimental resizable vector API, allowing vectors to be allocated with a maximum capacity and resized up to that capacity without reallocation.

This talk examines what this official API enables for high-performance data structures, using data.table as a case study. data.table has long relied on reference semantics and disciplined memory management to support efficient in-place column updates. With capacity-aware vectors available at the C level, amortized O(1) append patterns are now directly supported by R itself.

We explore how this mechanism can be used to enable efficient row growth and controlled row deletion, while respecting R’s sharing semantics, garbage collection, and attribute invariants. We discuss key constraints, including interactions with NAMED semantics, ALTREP materialization, serialization behavior, and cross-version compatibility.

Rather than changing R’s semantics, the resizable vector API formalizes a capacity concept that was previously implicit. This opens the door to safer, more predictable in-place operations in performance-critical R packages.

Speaker: Benjamin Schwendinger (Fraunhofer Austria Research GmbH)

growable_vectors_datatable_useR2026.pdf

107 cloud::servers[workload == R][order(cost_efficiency)][1, eval(task)]

Selecting the right cloud instance type for model training or other compute-intensive R workloads is often a guesswork:

1. Unclear resource requirements, e.g. "How much RAM do I need to train this hierarchical model?" or "Can my script scale to multiple CPU cores or even GPUs?"
2. Pricing and hardware specs exist, but are fragmented across vendors and hard to compare, especially when real workload performance matters.

We introduce Spare Cores, an open-source EU-funded project dedicated to help data scientists optimize their cloud resource utilization via

1. Resource Tracker: an open-source lightweight tool to auto-monitor the CPU, GPU, memory, VRAM, network traffic, disk etc. utilization of the server and running processes to build baselines, utilization profiles and early recommendations for server configurations and placements;
2. Navigator: an open dataset covering thousands of cloud instance types across small providers to hyperscalers with standardized performance and cost-efficiency metrics we benchmarked and collected over the past years.

This talk focuses on how such instance choice becomes a data task in R: filter by workload, hardware, compliance, or budget, then rank candidates by price-performance to identify the most efficient option for your workload.

Speaker: Gergely Daroczi

"cloud::servers[workload == R][order(cost_efficiency)][1, eval(task)]" slides

108 Explosive debugging with the 'boomer' package

Debugging in R often relies on manually inspecting intermediate results, usually by adding print statements to track the evolution of variables. The {boomer} package simplifies this process by automatically displaying these results in a readable and flexible way, without even modifying the code of the analyzed functions.

It gets its name from the fact that it “explodes” a call into its different parts, recursively, displaying the results of those that have been evaluated.

This presentation introduces its main features, their uses for debugging and teaching, as well as the design choices that rely on modifying the environment of functions rather than their code.

By the end of the presentation, the audience will have discovered new debugging strategies and gained insight into advanced meta-programming mechanisms.

Speaker: Antoine Fabri (cynkra)

Antoine Fabri - Explosive debugging with boomer.pdf

109 Futurize - Tearing Down Parallelization Barriers in R with Transpilers

Ever felt like parallelizing your R code requires a complete rewrite? Transitioning from sequential code to parallel execution has traditionally meant dealing with fragmented, obscure, package-specific APIs that distract us from our main goals. Which packages and functions should I use, and what platforms should I support? There are a lot of upfront decisions to make, with many hard-to-understand technical details. Many of us give up right there, keeping our analyses stuck with long-running, sequential processing. This "refactoring tax" prevents a lot of code from reaching its full potential.

In this presentation, I am introducing the futurize package (https://futurize.futureverse.org/), which is a next-generation parallelization tool that leverages the already widely adopted, well-tested Futureverse parallelization ecosystem. The new futurize() function is all you need to know - it is a universal parallelization adapter that lowers the barriers to parallelization to a minimum. It works out of the box with popular map-reduce (split-apply-combine) in base R, purrr, plyr, foreach, BiocParallel, and more. Combined with R's native pipe operator, the logic of your code remains the same, e.g., ys <- map(xs, slow_fcn) |> futurize(). The same strategy works for a growing set of domain-specific packages, including boot, caret, and lme4.

I will demonstrate how to use futurize() and how it strictly separates the declaration of what to parallelize from the end-user's choice of how and where the parallelization will take place. We will learn how to switch from sequential processing to local parallelization, to parallelization on multiple computers, in the cloud, on high-performance compute (HPC) clusters, and even on peer-to-peer (P2P) clusters, without changing the code itself. We will cover the concept of transpilation - the automatic code-rewriting technology that makes futurize() automate the tedious, error-prone code refactoring that we previously had to do manually. I will also showcase how the same technology can be used to inject progress-reporting code with a single universal progressify() function, regardless of whether sequential or parallel processing is used.

Speaker: Henrik Bengtsson (University of California San Francisco (UCSF))

Futurize - Tearing Down Parallelization Barriers in R with Transpilers - Easy!

Talks: R ecosystem, sustainability and scaling

Convener: Heather Turner (University of Birmingham)

110 An Investigation of the R Package Ecosystem: Insights from the crawlR Project

Listing over 23,000 Packages on CRAN alone, the R ecosystem provides a plethora of general-purpose and domain-specific packages. While there is a strict quality standard for packages to be accepted on CRAN, there is little information available about the evolution and current state of the ecosystem.
With the crawlR project, we statically analyzed all versions of all packages available on CRAN to gain insights into the evolution of the ecosystem and various aspects of package development and maintenance such as the use of semantic versioning, the prevalence of dead code, uncalled functions, and more.
To achieve this, we first analyze each package version individually using flowR, a static program analysis framework for R, to obtain a package-wide dataflow graph alongside call and control-flow information. We then use this information to extract a wide range of interesting aspects about the package including all of its functions and objects, such as the transitive package dependencies, call graphs, usage of language features, unreachable code, and more, obtaining roughly 80 GB of data for around 170,000 package versions.
In this talk, we present our methodology alongside the architecture of crawlR, explore the results, and provide a summary of our findings and insights obtained so far.
We also highlight open challenges for the ecosystem which we identified through our analysis and discuss interesting queries that we want to explore in the future with the help of the community.

Speaker: Florian Sihler (Ulm University)

noanim-presentation.pdf

presentation.pdf

111 The (aggregated) history of every CRAN package ever

CRAN represents and curates a complex software ecosystem of over 25,000 packages. This ecosystem constantly evolves as packages are submitted, updated, and archived. We analysed the development of CRAN over its entire lifetime, both in terms of package inter-dependencies and the internal structures of every version of every package. These analyses used the "pkgstats" tool for static code analysis, developed by rOpenSci, to analyse the statistical properties of every version of every CRAN package. Statistics measured by "pkgstats" include metadata on authorship and licenses; message translations; numbers of files, functions, lines of code, and lines of documentation; analyses of function calls both within a package and to functions defined in external packages; package dependency networks; and many other aspects. All of these statistics were analysed both over the entirety of CRAN on every day of its evolution, and on every package across sequential releases. Results reveal a contrast between the collective evolution of CRAN, and the evolution of individual packages. The CRAN ecosystem is becoming less stable because of an increasing dominance of new packages, yet this is counter-balanced by an increase in stability through individual packages becoming more mature. Balancing these confounding effects emerges as a key aspect of maintaining the stability of the complex software ecosystem of CRAN.

Speaker: Mark Padgham (rOpenSci)

The (aggregated) history of every CRAN package ever

112 R Analysis and the Math of Automation at Scale

The R language can be found on laptops, servers, clusters and high performance compute environments as well as embedded within databases, services, agents and business domain solutions. As the sheer number of analyses, more compute intensive analysis methods and the size of data steadily increases, using R for analysis at scale is becoming a math problem that seems to have no one simple answer. Add automation that never sleeps or takes a holiday, and the equation becomes more complex. We consider some basic and different approaches to manage the balance of available resources with the increasing demand for immediate analysis results, while ensuring that the analysis you perform on your laptop can be run at scale in high performance environments and clusters.

Speaker: Magnus Mengelbier (Independent / Freelancer)

user-2026-r_automation_scale.pptx

Virtual Presentation Room

Convener: Maciej Szymkowski (Future Processing, Bialystok University of Technology)

113 Sparge plots for comparing univariate distributions with many overlapping data points

The visualization of data embodies a visceral fundament for understanding, and constitutes a cardinal mechanism for modern communication of any measurement outcomes of research—despite typically being neglected (largely for technical reasons) in traditional statistics literature. There are limitless ways of realizing plots of data, and visualizing even the most basic distribution of points proves to be no exception to this generalization. An exceedingly popular way of plotting univartiate data—for exploratory data analysis and visual comparison—is by means of the ‘box plot’ which demarcates the median, quartiles, and outliers of a distribution—using a central as well as exterior lines of the rectangular box overlay. Other examples of similarly informative plots, that can compare data from several sources or across different experiments or data-sets, include the ‘strip-chart’ and the ‘forest plot’. Key shortcomings and constraints in many such approaches include an inability to represent large datasets along with the related issue of over-plotting of such points with near identical values—all while still highlighting distributional scaffolding demarcations. Other methods that can circumvent these problems include 'violin', 'sina', and 'raincloud' plots, which alleviate many such side-effects of simultaneously assessing large clusters of over-plotted points. Here I offer a re-incarnation of distributional plot to this family of statistical visualizations—as the 'sparge plot'—which leverages R's feature of translucent over-plotting to reflect an underlying density of overlapping points. I have additionally engineered a way to add an over-plot of a subtle (automatically gray-scaled) boxplot-frame around the the core of the data when this central area becomes overly dense. This novel plotting approach facilitates a dualistic solution to transparently visualizing both the density, distribution, and spread of data—as well as potentially overlapping data-points and outliers—for larger sample sizes.

Speaker: David Schruth (UW)

UseR-2026-Schruth-sparge.plot-screencast-TALK.mp4

114 Beyond Shiny: Building Native Desktop Applications with R

R has long been recognized for its statistical computing power, and Shiny has revolutionized how R users build interactive applications. However, deploying Shiny apps as standalone desktop software remains cumbersome - requiring a browser, a running R session, and often a server infrastructure. What if R could power true native desktop applications?
This talk introduces an architecture for building cross-platform desktop applications with R at their core. By combining Tauri - a lightweight Rust-based desktop framework - with a JSON RPC protocol over standard I/O, we can embed R as a computational engine inside native desktop apps, complete with modern UI, file system integration, and offline
capability.

Drawing on practical experience, I will present the key design patterns that make this approach viable: a long-running R server process communicating via structured messages, bundled R runtimes for zero-dependency distribution, and reproducible environments through renv. I will discuss the challenges encountered - process lifecycle management across operating systems, data serialization between R and frontend frameworks, and packaging a full R distribution for end users - and the solutions that emerged.
Looking forward, I will outline a vision for a general-purpose R package that abstracts these patterns into a developer-friendly API, enabling any R programmer to build and distribute desktop applications as easily as they build Shiny apps today. The goal: desktop::run() instead of shiny::runApp().

This talk is for R developers who have hit the limitations of browser-based apps and want to explore what native desktop development with R could look like.

Speaker: Anastasiia Kostiv

useR2026_beyond_shiny_kostiv.mp4

115 Interactive Bubble Charts in R Made Simple with nivo.bubblechart

How do you bring modern, interactive data visualizations into R without writing JavaScript? The nivo.bubblechart package lets R users create responsive, animated circle packing charts using a familiar data frame workflow. Built on top of the Nivo visualization library (React + D3), it provides clean defaults, customizable colors and interactivity, and seamless Shiny integration with click and hover events - all from a few lines of R code. I will demo the package live and share lessons learned from building an htmlwidgets-based bridge between R and a React component library.

Package: https://dataraceredu.github.io/nivo.bubblechart/

Speaker: Anastasiia Kostiv

useR2026_nivo_bubble_kostiv.mp4

116 Predicting IPL Match Outcomes Using Machine Learning and Ball-by-Ball Cricket Data Analysis in R

The rapid growth of sports analytics has enabled researchers to use data-driven techniques to understand performance patterns and predict outcomes in competitive sports. Cricket, particularly the Indian Premier League (IPL), generates a large amount of structured match data that can be analyzed to study team strategies, player performance, and match dynamics. This project focuses on analyzing IPL match data and predicting match outcomes using statistical analysis and machine learning techniques implemented in the R programming environment.

The study utilizes a ball-by-ball IPL dataset that provides detailed information about every delivery in a match, including the batsman, bowler, runs scored, extras, wickets, overs, and match context. The dataset is first cleaned and preprocessed in RStudio to ensure accuracy and consistency. Data preprocessing includes handling missing values, organizing variables, and preparing the dataset for further analysis. Exploratory Data Analysis (EDA) is then performed to identify patterns and relationships between match variables and match results.

Key concepts of this project include sports data analytics, exploratory data analysis, feature engineering, and predictive modeling. Important match features such as run rate, wickets remaining, overs completed, powerplay performance, and death-over scoring trends are extracted to understand the factors that influence match outcomes. Visualization techniques using R packages such as ggplot2, dplyr, and tidyr are applied to examine team performance, venue scoring patterns, and player contributions across different stages of the match.

Machine learning models including Logistic Regression and Random Forest are implemented to predict the probability of a team winning under different match situations. These models are trained using historical IPL data to analyze how different match conditions influence the final result. The project demonstrates how statistical analysis and machine learning techniques in R can be applied to sports datasets to generate meaningful insights.

Overall, this study highlights the importance of sports analytics in modern cricket and shows how historical IPL data can be used to build predictive models and support data-driven decision-making in cricket analysis.

Speaker: Dr Prince Sharma (Indian Institute of Information Technology Una)

Correction.docx

IPL Match Outcomes.pdf

MLMatchPredictorPSV.mp4

117 Make your Shiny dashboard screen reader friendly

Online dashboards use data visualizations to quickly convey information. Interactive elements like charts and data filters often display additional information not accessible by screen readers. Accessibility features improve the overall presentation and user experience by augmenting, amplifying, and enhancing the content so that users can interact with and understand the same content in multiple ways, depending on their needs and preferences.

Our presentation will demonstrate in a simple Shiny dashboard how to address several accessibility issues that someone who uses a screen reader might encounter. We will briefly introduce the dashboard, then we will cover each of the failed checks. For each check, we will demonstrate the issue, show a way to revise the dashboard code to address it, and demonstrate how the check passes on the fixed dashboard.

The failed checks include the following.

1. The dashboard's language is not defined.
2. The filters are labelled only with vague keywords.
3. The only way to access the information in the charts is by looking at them.
4. There are no descriptions or explanations for the charts.
5. There is no alternative text for charts.

All files, including the presentation, starting script, and suggested solution script, will be downloadable from the GitHub repository https://github.com/ajstamm/shiny-a11y-app for attendees who wish to code along. Our past presentations on accessibility in Shiny dashboards can also be found here.

Speakers: Abigail Stamm (Minnesota Department of Health), Eric Kvale (Minnesota Department of Health)

kvale-stamm-user-accessibility-trim.mp4

118 Please correct to safely retain your package on CRAN

Generally, CRAN packages are expected to keep passing their tests, and their updates should not break other packages. Debugging the occasional failure of this process can lead the developer down a very deep rabbit hole: our dependency stacks are very deep, and none of the layers are completely bug-free.

We're going to see how problems from real CRAN packages could be investigated and solved or at least worked around, including such causes as:

• real bugs in the package that surface for surprising reasons
• bugs in the compiler (but only when sanitizer is enabled)
• bugs in the compiler (when link-time optimisation is used)
• C standard arcana that become relevant when using a lot of CPU time
• CPU time spikes due to a dependency's .onLoad
  • and how to use the event profiler in Linux to debug excessive CPU use
• bugs in Valgrind, a bug-finding tool

While the symptoms initially looked puzzling, in the end there was an explanation for every one of them.

Speaker: Ivan Krylov (Lomonosov Moscow State University)

slides.pdf

useR2026_Krylov.mp4

119 Synthetic by Design: Two R Packages for Privacy-Safe Public Health Data Generation

Access to realistic public health data for training, pipeline validation, and methods development is constrained by privacy regulations that restrict use of real patient records. We present two complementary open-source R packages that address this problem at different points along the synthetic data design spectrum.

toysurveydata (Stamm, MDH) generates simple, customizable fake survey datasets from a priori response proportions, without modeling inter-variable relationships. Designed for demonstrating data cleaning and validation workflows, it offers a lightweight, settings-table–driven approach that prioritizes usability over epidemiological fidelity.

The NSSP Synthetic Data Toolkit (Kvale, MDH) occupies the other end of the spectrum: a modular Shiny dashboard generating HIPAA-safe emergency department visit data modeled after the CDC National Syndromic Surveillance Program BioSense Platform. Its architecture includes a data definitions module implementing the full NSSP Data Dictionary field structure, a baseline generator with configurable demographic distributions and temporal visit patterns, a ten-scenario disruption engine, and export utilities producing CSV, JSON, and HL7-like outputs across all five BioSense tables.

A recently added scenario simulates the downstream healthcare utilization impacts of federal immigration enforcement operations, modeling suppressed care-seeking behavior, ED volume shifts, syndromic surveillance signal changes, and behavioral health surge patterns — a novel application of synthetic data generation to an emerging and politically sensitive public health research problem.

Together these packages illustrate how synthetic data design choices — complexity, fidelity, and domain specificity — should be driven by the intended training or research use case. Both are freely available on GitHub.

• toysurveydata: https://github.com/ajstamm/toysurveydata
• NSSP Toolkit: https://github.com/ekvale/nssp-synthetic-data

Speakers: Abigail Stamm (Minnesota Department of Health), Eric Kvale (Minnesota Department of Health)

kvale-stamm-user-synthetic-data-trim.mp4

120 One Rating, Multiple Services. Solving the 100-Service Dilemma: Automated Attribution for Multi-Service Public Satisfaction Surveys

Scaling public satisfaction surveys presents a significant challenge for government hubs managing hundreds of distinct services. National regulations of Indonesia (Minister of Administrative and Bureaucratic Reform Regulation 14/2017) mandate measuring nine specific quality components—including staff behavior, requirements, and facilities—for every service provided. However, requiring citizens to repeat identical ratings for each individual service they receive in a single visit leads to severe respondent fatigue and compromised data quality.

This case study demonstrates a "One Rating, Multiple Services" strategy powered by a robust R-based pipeline. We implemented a streamlined data collection workflow using Google Forms, where respondents select all services received (stored as semicolon-separated strings, e.g., "Service A; Service B; Service E") and provide a single set of ratings based on their holistic experience.

Using the {tidyverse} ecosystem—specifically the separate_longer_delim() function from {tidyr}—we developed a "Disaggregate-and-Attribute" pipeline. This workflow automates the duplication of perception scores across specific service IDs, enabling the calculation of individual satisfaction indices for hundreds of services from a manageable volume of raw survey entries. This presentation highlights how R serves as a critical tool for bridging rigid bureaucratic mandates with efficient, human-centric data collection strategies in the public sector.

Speaker: Abdul Aziz Nurussadad (Badan Informasi Geospasial)

2026 - One_Rating_Multiple_Services.pptx

(GITHUB) One Rating, Multiple Services

One Rating Multiple Services - Abdul Aziz Nurussadad.mp4

121 Movie Recommendation Model

This project presents the development of a movie recommendation system implemented using the R programming language. The primary objective of the project is to design a data-driven model capable of suggesting relevant movies to users based on patterns identified in historical rating data. R was chosen for this project due to its strong capabilities in statistical computing, data analysis, and visualization.

The contribution of R in this project begins with data preprocessing and exploration. Large movie rating datasets were imported, cleaned, and structured using R libraries such as dplyr, tidyr, and readr. Missing values, inconsistent entries, and redundant data were handled to ensure reliable input for the recommendation model. Exploratory data analysis was conducted using ggplot2 to identify user rating trends, popular genres, and distribution patterns within the dataset.

R was also used to implement the core recommendation algorithm. Collaborative filtering techniques were applied using packages such as recommenderlab, enabling the system to identify similarities between users and movies. By constructing a user–item rating matrix, the model predicts unseen ratings and generates personalized movie recommendations. Matrix operations and similarity measures such as cosine similarity were utilized to improve recommendation accuracy.

Furthermore, R facilitated model evaluation and performance analysis. Metrics such as precision, recall, and prediction accuracy were computed to assess the effectiveness of the recommendation system. Visualization tools were used to interpret model performance and recommendation quality.

Overall, this project demonstrates how R can be effectively utilized for building a complete movie recommendation pipeline, including data preprocessing, model development, evaluation, and visualization. The use of R enables efficient handling of large datasets and provides a flexible environment for developing scalable recommendation systems.

Speaker: Dr Prince Sharma (Institute of Information Technology, Una)

MovieRecommendationModel.png

MovieRecommendationModelPPT.pptx

Presentation.mp4

122 What Wins the EPL Trophy? Player Quality, Tactics, or Money? A Multi-Season Regression Analysis Using R

What determines success in the English Premier League — superior
player quality, tactical approach, or transfer investment? This
study addresses that question empirically using R and the
worldfootballR package.

We construct a panel dataset of 100 team-season observations
across five EPL seasons (2019/20 to 2023/24) by combining FBref
and Transfermarkt data via worldfootballR. Three blocks of
predictors are defined: player quality (net expected goals,
finishing overperformance), tactical approach (possession,
progressive passes, pressing success), and financial investment
(gross and net transfer spend). Final league points is the outcome
variable.

Block OLS regression models and incremental F-tests are used to
quantify the independent contribution of each factor. Results show
that player quality — proxied by net expected goals — is the
strongest predictor of final points, explaining the largest share
of variance. Tactical indicators add significant additional
explanatory power. Transfer spend alone is a considerably weaker
and noisier predictor than either preceding factor.

This talk demonstrates a fully reproducible R workflow using
worldfootballR, tidyverse, ggplot2, broom, and patchwork —
from automated data extraction to regression modelling and
publication-quality visualisation.

Speaker: Ayush Pundir (IIIT UNA)

Untitled design.mp4

userR final poster.pdf

123 Using R to Estimate Animal Population Densities

Author information:

Melissa Bather is a statistician from New Zealand, currently living in Vancouver, BC, Canada. She has a Master of Science in Statistics with First Class Honours from the University of Auckland—the birthplace of R! She is currently researching new methods to introduce multi-species models into the field of spatially explicit capture-recapture for the University of Auckland as well as working as a Product Operations Manager in AI.

Primary topic: Spatially explicit capture-recapture modelling with R

Abstract:

How do we know how many animals there are? When I was a child, I thought that ecologists ventured into animal habitats and counted every animal one by one. It turns out there is a much more efficient way to do this using statistics with the help of R.

Spatially explicit capture-recapture (SECR) models estimate animal population densities by modelling where and when animals are detected across an area of interest. They are important tools for conserving, monitoring, and managing animal species. Animals can be detected in many ways, including trapping and tagging, hair snares, camera traps, and even microphones that record animal vocalisations. This allows researchers to study animals from a broad range of sizes—from tiny mice and frogs all the way to grizzly bears and even whales—and in a wide range of different habitats. There are a handful of R packages that allow us to build SECR models quite simply using animal capture histories from numerous detection methods, including secr, ascr, and a newer package acre which is particularly good for acoustic SECR models.

This talk will introduce common animal detection methods, show how detections are recorded as capture histories, and demonstrate how SECR models can easily be implemented and interpreted in R.

Previous conferences:

I previously presented a talk about the same topic at the Cascadia R Conf in Seattle, Washington in 2023, however, this talk will have a stronger focus on R in particular.

External resources:

acre R package: https://github.com/b-steve/acre

secr R package: https://cran.r-project.org/web/packages/secr/secr.pdf

ascr R package: https://github.com/b-steve/ascr

Speaker: Melissa Bather (The University of Auckland)

Slides

useR recording.mp4

Lightning Talks

Convener: Filiz Karadag (Ege University)

124 To Save or Not to Save: Parallel Bayesian Testing for R Packages

The development of R packages for Bayesian analysis is often slowed by the computationally intensive nature of MCMC sampling, which turns iterative testing into a major bottleneck. A recurring challenge in this domain is the trade-off between saving large fitted model objects to disk versus regenerating them on each test run, a question coming up repeatedly during local development, continuous integration and collaborative workflows. This work introduces a framework to address this challenge by integrating robust testing strategies with CPU parallelization.
Our approach leverages the testthat framework, using setup.R to manage testing environments consistently across local R sessions, Posit Workbench and continuous integration (CI) pipelines. Model objects are generated only once per test run and shared across test files, balancing storage overhead against computational cost.
A key innovation is the parallelization of the sampling process itself within setup.R, with benchmarks demonstrating significant reductions in running time. By combining object caching with parallel execution, this framework transforms a traditionally slow workflow into an efficient, scalable process and offers a template for developers of computationally demanding R packages.

Speaker: Shuai Wu (MSD)

useR2026_v4.pptx

useR2026_v5.pptx

125 Imputation methods and their benchmarking for fuzzy datasets with R

Imputation methods are widely used to replace missing values in datasets, thereby improving the overall quality of samples and enabling further statistical procedures. Various measures and tools were proposed to compare the effectiveness and results of the imputation algorithms. However, they only aim at “crisp” (i.e., real-valued) datasets. Meanwhile, fuzzy sets are widely used to model imprecision in data (e.g., when the results of an experiment cannot be precisely described, qualified, or measured) in fields such as biology, engineering, and reliability. The package FuzzyImputationTest is devoted to imputing and benchmarking the special case of datasets consisting of fuzzy numbers. This library is a unique combination of classical tools and new measures that address specific features of fuzzy sets (such as the existence of a membership function, inequalities related to the position of the core and support, etc.). Apart from various measures of “similarity” between the actual and imputed values, statistical tools, including special epistemic bootstrap tests, are also applied. With the help of FuzzyImputationTest, five imputation methods (the widely known missForest, miceRanger, knn, and pmm algorithms, together with the completely new method designed explicitly for fuzzy data - dimp) are numerically compared across various synthetic, real-life, single- and multivariate datasets. The obtained conclusions shed new light on the existing, yet still overlooked, problem of imputing missing fuzzy data.

Speaker: Maciej Romaniuk (Systems Research Institute, PAS)

AMCS_2026_36_2_4.pdf

prezentacja_user_2026_v1.pdf

Lightning Talks: Machine learning

Convener: Heather Turner (University of Birmingham)

126 FoReco and FoRecoML: Unified Forecast Reconciliation in R

Forecast reconciliation has become key to improving the accuracy and coherence of forecasts for linearly constrained multiple time series, such as hierarchical and grouped series. Yet, comprehensive software that jointly covers cross-sectional, temporal, and cross-temporal reconciliation has so far been lacking. The R packages FoReco and FoRecoML address this gap by offering a comprehensive and unified framework. The packages respectively implement classical and regression-based linear reconciliation approaches, and non-linear approaches based on machine learning for cross-sectional, temporal and cross-temporal frameworks. Designed for accessibility and flexibility, these packages provide sensible default options that allow new users to apply reconciliation methods with minimal effort, while still giving expert users full control to explore state-of-the-art extensions through customized settings. With this dual focus, FoReco and FoRecoML are versatile tools for practitioners and researchers working on forecast reconciliation.

Speaker: Daniele Girolimetto (Department of Statistical Sciences, University of Padova)

UseR_slides.pdf

127 celecx: Active Learning for Computer Experiments in R

To explore the behaviour of expensive black-box functions, such as machine learning model evaluations or physical simulations, it is often useful to fit a surrogate regression model to a sequence of evaluated points. Choosing these points adaptively, rather than relying on a pre-specified design, is advantageous because it places greater emphasis on regions of the configuration space where the regression model is most uncertain. This adaptive, sequential selection of evaluation points is the core idea of active learning for computer experiments.

celecx is a new package in the mlr3 ecosystem that extends its functionality for black-box optimization and surrogate modelling toward active learning. It offers both a high-level user interface with sensible defaults and modular components that can be configured for specialized use cases. A particular focus of celecx is on diagnostics for assessing the quality of the surrogate fit and extrapolating the performance that can be achieved, and at what cost, through additional evaluations.

Speaker: Martin Binder (Department of Statistics, LMU Munich; Munich Center for Machine Learning (MCML))

celecx: Active Learning for Computer Experiments in R (Google Slides)

celecx Active Learning for Computer Experiments in R.pptx

14:30 Coffee Break

128 In memoriam: Tomáš Kalibera

Speaker: Simon Urbanek

Keynote: Release management and governance structure of the R project

Conveners: Gergely Daroczi, Peter Dalgaard

129 Release management and governance structure of the R project

Abstract:
R grew out of the PC, Internet, and Open Source revolution in the 1990s. I will give an account of the early history of R, and then outline the development principles of R Core, with special focus on release management. However, the R Core Team is not alone in the governance of the R project, other major actors being the CRAN team, the R Foundation and the R Consortium. I discuss their contributions with a view to sustainability and possible improvements.

Bio:
Member of the R Core Team since 1997. Professor of Statistics at Copenhagen Business School since 2010, and before that almost 25 years at the Department of Biostatistics at the University of Copenhagen.

Speaker: Peter Dalgaard

Dalgaard-keynote.pdf

Social: Conference Group Photo

Poster

130 The dpGMM package for stable initialization in Gaussian Mixture Modeling

Gaussian Mixture Modeling (GMM) is a one of unsupervised techniques used in many fields of data analysis, such as bioinformatics, pattern recognition, and network traffic analysis. Yet, existing R implementations often lack support for binned data (commonly observed in image analysis) and suffer from initialization instability or massive memory usage. To address these limitations, the novel R package dpGMM was introduced. It is specifically designed for robust decomposition of 1D and 2D data, supporting both continuous and binned encodings. The core implementation utilizes the recursive Expectation-Maximization (EM) algorithm, accompanied by a deterministic dynamic programming (DP) initialization strategy based on the Bellman recurrence. For 1D data, the DP algorithm partitions the histogram to accurately estimate initial weights, means, and variances. For 2D data, the implementation leverages boundary distributions to generate aggregated components, which are then iteratively pruned by maximizing the log-likelihood.
To ensure algorithmic stability during EM iterations, dpGMM implements a "pin component" avoidance mechanism. This feature introduces a user-controlled minimum-variance parameter to prevent divergence typically caused by isolated or repeated measurements. Architecturally, the package operates as a flexible wrapper, facilitating both fixed-component fitting and automated model selection via information criteria (e.g., AIC, BIC) paired with an early-stopping Likelihood Ratio Test. Furthermore, the post-processing module includes a hybrid threshold estimation approach that prioritizes Bayes-optimal decision boundaries based on quadratic equations, systematically falling back to the Maximum a Posteriori rule when the discriminant is negative. Performed a broad benchmarking process confirms these specific implementational advancements provide superior parameter estimation and computational efficiency compared to known packages such as mixtools, ClusterR, and mclust. The presented dpGMM is available on CRAN as well as GitHub service under a link https://github.com/ZAEDPolSl/dpGMM

Acknowledgments: This work has been supported by the Silesian University of Technology grant for maintaining and developing research potential for 2026.

Speaker: Joanna Zyla (Department of Data Science and Engineering, Silesian University of Technology, Gliwice, Poland)

Zyla_useR_2026.pdf

131 Interactive and Instant: GenAI-Driven Creation of Clinical Trial Applications

Building exploratory analysis dashboards for clinical trials requires considerable expertise, extensive time, and deep familiarity with specialized frameworks. In this talk, we share our GenAI solution to significantly streamline this process. We will present a tool, powered by Claude Code, that enables biostatisticians and clinical researchers to effortlessly create and immediately preview applications tailored for exploratory clinical data analysis using {teal} R package.
Throughout our journey, we experimented with various GenAI-driven solutions, including code editors integrated with AI assistance tools, and approaches leveraging MCP servers. Current implementation is an interactive AI-powered chat interface designed to simplify the application-building experience, providing users with immediate previews, and reducing both development complexity and the learning curve associated with the {teal} package.

We will demonstrate how GenAI-driven solutions can empower users with limited programming backgrounds to rapidly build effective exploratory analysis dashboards, discuss challenges encountered, and highlight insights gained through our iterative development process.

Speaker: Marcin Dubel (Appsilon)

TealFlow_Mediforce_poster_A0.pdf

132 From Static to Smart: Exception-Driven Medical Data Review with Teal and AI

Medical Data Review (MDR) in clinical trials requires study teams to examine patient-level data across dozens of CRF domains — adverse events, labs, vitals, ECGs, and more. Traditionally, this relies mainly on static listings generated per study, requiring extensive setup and line-by-line inspection. We present an R framework, built on teal, that replaces this workflow with interactive, intelligent, and reusable review applications.
The first layer is a template system: over 30 pre-built teal modules covering common MDR domains and indications (AE listings, lab panels, Hy's Law plots, ECG graphs, RECIST, discontinuation summaries). A single function scaffolds a complete application for any study by composing modules and wiring them to the study's data files.
The second layer adds intelligence. Audit trail integration detects records changed since a cutoff date and highlights modified cells with their previous values. An automated verification layer cross-references data across domains: AE-Lab discrepancy detection flags adverse events lacking corresponding lab entries, severity grade escalations are color-coded for immediate visibility, and serious AE indicators, drug withdrawals, and suspect drug flags are surfaced automatically. This shifts review from exhaustive scanning to targeted, exception-driven investigation.
An embedded AI assistant, connected to the live Shiny session via the Model Context Protocol, enables reviewers to query data conversationally — "which subjects have grade 4 AEs without drug withdrawal" — with answers grounded in the actual filtered dataset.
The poster demonstrates the architecture, cross-study scalability, and early results on review time reduction. The framework is built in R using teal, reactable, arrow, and bslib.

Speakers: Ms Daphne Grasselly (Roche), Magdalena Krochmal (Roche)

useR! 2026 - teal MDR poster.pdf

133 Patient Timeline Visualization: Presenting Individual and Population-Level Clinical Trial Journeys with R and D3.js

Clinical trial data analysis typically focuses on specific analysis datasets, but the complete journey of individual patients — from screening, enrollment, and first dose, through visit records and adverse events, to last dose and survival status — represents critical time-based data points that reviewers prioritize. This fragmentation of information forces reviewers to switch between multiple reports during in-depth case reviews.

This poster presents an interactive patient timeline visualization system built with R and D3.js. The single-patient view integrates visit records, medication history, adverse events, and survival status into a clear timeline, providing a complete picture of each patient's key trial journey.

The system also supports side-by-side timeline comparisons across patient subgroups, with event type filtering and time range zoom functionality to help identify population-level event patterns and safety signals.

The system takes raw CRF data as input and embeds D3.js interactive capabilities directly into the R workflow, without requiring a separate front-end development environment. This poster will demonstrate visualizations generated from simulated clinical trial data and discuss the practical potential of this approach in clinical data review and safety monitoring settings.

Speaker: Winkle Lu

useR_2026_Winkle_Poster_Final.pdf

134 TheseusPlot: Visualizing Decomposition of Differences in Rate Metrics

TheseusPlot is an R package for explaining why a rate metric (e.g., conversion rate, retention rate, or on-time rate) differs between two groups, such as time periods, cohorts, or A/B variants. The package decomposes an overall difference into contributions from individual subgroups using a procedure inspired by the Ship of Theseus: starting from Group A, it replaces subgroup data with the corresponding data from Group B step by step and recalculates the overall rate after each replacement. The resulting stepwise changes quantify each subgroup’s contribution to the total difference.

TheseusPlot visualizes this decomposition as a Theseus Plot, which combines the stepwise progression of a waterfall plot with comparative bars showing subgroup sizes in both groups. This makes it easier to distinguish “large impact due to a large shift” from “large impact due to large volume” and to communicate findings to stakeholders. Users create a reusable “ship” object from two data frames that share common columns and then generate Theseus plots for any categorical variable; for high-cardinality variables, small contributors can be aggregated and the plot can be flipped for readability.

TheseusPlot supports reproducible root-cause analysis for KPI changes in product analytics, experiments, and operational metrics, and is available on CRAN.

Speakers: Daisuke Ichikawa (Kibaroku), Koji Makiyama (HOXO-M Inc.), Shinichi Takayanagi, kazuyuki sano

TheseusPlot_useR2026_poster.pdf

135 Estimating Poland’s Natural Rate of Interest in R: A Bayesian VECM Workflow for Cointegration, Model Selection, and Monetary Policy Stance Analysis

This study presents an end-to-end R-based workflow for estimating Poland’s natural rate of interest within a Bayesian vector error-correction setting. The empirical objective is to recover an equilibrium real interest rate and the associated monetary policy stance gap, whereas the methodological contribution lies in demonstrating how advanced macroeconometric inference can be structured, diagnosed, and reported within the R ecosystem. The framework integrates quarterly macro-financial data preparation, Z-score standardization, Bayesian lag-length and cointegration-rank selection, posterior simulation, uncertainty quantification, and historical decomposition. Model selection is conducted using rolling log predictive scores, MAP-type posterior model probabilities, and Savage-Dickey density ratios. Estimation is implemented primarily with bvartools, while zoo and xts are used for time-indexed data handling, dplyr and purrr for pipeline structuring, ggplot2 and gt for analytical reporting, and coda for posterior diagnostics. A central implementation feature is draw-by-draw normalization of the cointegration vector on the ex ante real policy rate, combined with equal-tailed 68% credible intervals and stability filtering. The resulting natural-rate estimates are benchmarked against a Gonzalo-Granger permanent-component decomposition. The empirical results indicate relative stability of the equilibrium real rate outside major shock episodes, a marked widening of uncertainty during 2020–2021, and a higher post-pandemic equilibrium level than in the pre-COVID sample. Particular emphasis is placed on implementation choices, posterior diagnostics, robustness design, and the capacity of R to support high-level Bayesian macro-financial analysis in policy-oriented research.

Speaker: Patryk Kołbyko (Szkoła Doktorska Nauk Społecznych UMCS. Uniwersytet Marii Curie-Skłodowskiej w Lublinie)

user 2026 poster - Bayesian estimation of NRI in R Patryk Kołbyko improved.pdf

136 peRsian: A collection of Color Palettes from Persian Carpets

We present peRsian, an R package containing color palettes based on handcrafted Persian carpets for use in data visualization. peRsian is a tribute to centuries of Persian carpet-making, a craft that’s been alive for over two thousand years. It’s dedicated to the incredible artisans who’ve kept this tradition alive: especially the women who spent countless hours knotting and weaving every single thread, and the men who sheared the sheep, dyed the wool, and prepared the yarn. Working in harmony, they transformed simple fibres into carpets rich in colour, rhythm, and life.

To build the package, we’ve collected a diverse selection of images depicting Persian carpets, rugs, and gabbehs from our wider social networks. We extracted a set of colors from each image aiming to accurately represent the original color compositions. Each palette (and carpet) in the package comes with a small story of its own, often linked to and celebrating specific people.

The package further includes an empirical evaluation where we tested palettes for sufficient distance between colors and an additional check to highlight color-blind-friendly palettes within the package. The evaluation is included in the form of a vignette.

Speaker: Dr Jan Simson (LMU Munich)

peRsian final.pdf

137 Visualisation of results from large simulation studies: introducing the multi-performance plot and its Shiny app

Simulation studies allow comparisons of performance between statistical methods to be made. Tables are traditionally used to report study results, which are usually performance measures such as bias, empirical standard error, average model standard error and coverage. In large simulation studies, these tables of results may become too large for patterns to be readily identified. This occurs when many performance measures are assessed; many combinations of simulation parameters are evaluated, and many statistical methods are evaluated.

In this talk, we will introduce the multi-performance plot, a new way of compactly visualising the results from large simulation studies for easier pattern identification. We will describe how the plot can display up to seven performance measures comparing multiple statistical methods. In R, we will demonstrate with examples the implementation of the multi-performance plot, in addition to (i) its integration with the rsimsum package for simulation studies, and (ii) a Shiny app for the multi-performance plot.

Speaker: Dr Wang Pok Lo (University of Oxford)

multiperformanceplot_posterWPLv2.pdf

138 From Linear to Machine Learning: An Interactive Shiny Framework for Diagnostic Test Combination in R

Accurate diagnosis often requires the integration of multiple biomarkers rather than relying on a single test. However, existing tools for combining diagnostic tests are limited in methodological diversity and usability, especially for clinicians without programming expertise. To address this gap, we present dtComb-Shiny, a user-friendly web-based interface built on the dtComb R package. The dtComb framework integrates a comprehensive set of 142 combination methods, including linear, non-linear, machine learning, and mathematical operator-based approaches. The Shiny application extends this functionality by providing an intuitive, interactive environment where users can upload datasets, select markers, apply combination methods, and evaluate diagnostic performance without requiring coding skills. The application is developed in R using a modular architecture, where shiny handles the interactive interface, dplyr and stringr support data processing, and ggplot2 enables flexible visualization. User interface components are enhanced with shinyBS, and the system leverages reactive programming principles for efficient and scalable analysis workflows. Automated testing is performed using the shinytest framework to ensure reliability and reproducibility. The platform supports full analytical workflows, including preprocessing, model training with resampling strategies, ROC analysis, optimal cut-off selection, and detailed performance metrics such as sensitivity, specificity, PPV, and NPV. Additionally, it enables visualization through ROC curves, density plots, and sensitivity-specificity graphs, and allows prediction on new data using trained models.By bridging advanced statistical methodology with accessibility, dtComb-Shiny facilitates the adoption of sophisticated diagnostic test combination techniques in clinical and research settings. This tool empowers clinicians and researchers to improve diagnostic accuracy and make data-driven decisions more efficiently.

Speaker: Serra İlayda Yerlitaş Taştan (Department of Biostatistics, Erciyes University, Faculty of Medicine, 38030, Kayseri, Türkiye)

dtComb_shiny_useR_2.pdf

139 Now we'R coding! Bringing Agent Assistants Into Live R Sessions

AI code assistants such as Claude Code, opencode, and Aider can read, write, and run code. However, they work separately from the user's R session. They cannot look at live objects, call R functions, or update a running Shiny application. We present a way to connect these assistants directly to R and Shiny using the Model Context Protocol (MCP).

The main idea is to use CLI-based AI agents as chat providers in the R ecosystem. Instead of relying only on API-based models, users can connect to any CLI agent that supports MCP and get the same chat experience. The agent keeps its own tools, such as file editing, search, and shell access, while also getting access to custom R tools and live session data.

The connection works through MCP and the mcptools package. Together, they create a two-way link between the CLI agent and the running R process. The agent can call R functions, read session state, and in Shiny applications, change UI components in real time. The user talks to the agent through a chat interface, while the agent works with both the file system and the live R session.

The poster will show the architecture using Claude Code as an example, but the design works with any CLI agent that supports MCP. This makes it a general pattern for bringing AI coding assistants into R, Shiny, or other programming environments.

Speakers: Adam Forys (Roche), Magdalena Krochmal (Roche)

useR! 2026 - Now weR coding.pdf

140 FinDash Pro: An Integrated R Shiny Dashboard for Real-Time Financial Analysis, Machine Learning Forecasting, and LLM-Augmented Decision Support

The increasing complexity of financial markets demands analytical tools that combine real-time data access, rigorous statistical modelling, and intuitive visual communication within a single, reproducible framework. This study presents FinDash Pro, a production-grade interactive dashboard developed entirely in R using the Shiny ecosystem, designed to bridge the gap between institutional-level financial analytics and open-source accessibility.

FinDash Pro aggregates live market data from multiple sources, including Yahoo Finance via quantmod, the Tiingo API via riingo, and web-scraped fundamental metrics, and renders them through a polished dark-themed interface built with navbarPage, plotly, and gt/gtExtras. The dashboard encompasses four analytical modules, whcih are a Market Overview panel displaying S&P 500 capitalisation rankings with 30-day sparkline trends; a Stock Analysis panel featuring candlestick charts, technical indicators (RSI, MACD), and multi-stock comparison; a Portfolio Calculator with CAGR, annualised volatility, and Sharpe ratio metrics benchmarked against the S&P 500 index; and a News & Sentiment panel delivering real-time headlines with lexicon-based sentiment scoring via sentimentr.

The central methodological contribution is the Machine Learning Predictions module, which implements two complementary forecasting paradigms: a Long Short-Term Memory (LSTM) neural network via keras3 for 7-day-ahead price prediction with bootstrapped confidence intervals, and a Random Forest ensemble via randomForest for iterative daily return forecasting with feature importance attribution. The model were selected based on the literature review. Furthermore, the dashboard integrates a context-aware large language model (Google Gemini via ellmer) whose system prompt is dynamically populated with live price action and technical signals, enabling natural-language stock analysis grounded in real-time dashboard state.

FinDash Pro demonstrates how modern R tooling can deliver a coherent, extensible, and fully reproducible analytical platform that meets the demands of quantitative finance practitioners and data science educators alike.

Speaker: Ozancan Ozdemir (University of Groningen)

Oozdemir-findashpro.pdf

141 A Package for Performing Multiple Interrupted Time Series with Control

This package allows the user to perform interrupted time series (ITS) with a control across successive interventions (up to 3). This code is based on a prior analysis done at our county where we compared the effect of two successive behavioural interventions designed in improving the uptake of a COVID-19 booster intervention programme amongst immunosuppressed patients at several primary care practices within our county and from an rpub article detailing the methodology by Prof Chrissy Roberts at London School of Hygiene and Tropical Medicine.

Interrupted Time Series is a robust quasi-experimental design which can assess the performance of an intervention through the effects the intervention has on the level or slope of an outcome’s trend over time after a clear defined time point, and has wide applications in healthcare, public health, public policy, economics, social programmes etc. Multiple Interrupted Time Series with Control extends this method by allowing the possibility to compare pre and post-intervention trends while controlling for external factors via the control, to account for independent secular and periodic changes, and for successive interventions.

Functions in the package greatly streamline the process for the end user where each step of performing multiple ITS with control is guided in a step by step manner, from wrangling, to modelling, to data visualisation, to interpretation and key coefficient statistical significance testing.

Vignettes in the package demonstrate examples and provide guidance on how to apply the functions and interpret their findings.

Speaker: Victor Yu (Hertfordshire County Council, UK)

useR poster.pptx

142 persephone3: Object oriented wrapper around the seasonal adjustment packages in the rjdverse

persephone3 is the updated R framework developed at Statistics Austria to enable efficient processing of large sets of time series in the production of seasonally adjusted estimates. It modernizes the original persephone package by moving from the RJDemetra backend to the new rjd3 ecosystem, ensuring long term maintainability and compatibility with current JDemetra+ developments.
The package provides a streamlined workflow for handling single, batch, and hierarchical time series, reflecting operational needs within official statistics. It offers a range of analytic tools, including interactive plots and diagnostic visualizations that support experts in identifying outliers, assessing model behavior, and monitoring adjustment quality. Eurostat compatible quality reports can be integrated into the workflow, enabling standardized evaluation of adjustment results where required.

Speaker: Angelika Meraner (Statistics Austria)

persephone3 - Object oriented wrapper around the seasonal adjustment packages in the rjdverse

143 Git-based workflow for the validation of a R package

The use of R packages in a regulated environment as in pharmaceutical companies might require a formal validation of the R package.

The Validation Hub introduces best practices and insights from pharmaceutical industries for the validation of R packages for use within the biopharmaceutical regulatory setting.

We will contribute to this effort by presenting a git-based workflow to automate the creation of validation form of a R package with the help of the pkgTesteR R package.

The validation form of any R packages containing tests created with the testthat R package and tracked with git can be created with the R package.

The user requirements, extracted from the tests descriptions, are consistently and incrementally numbered since a base (production) version of the package based on the git history, to ensure consistency of the form across versions. The review of the validation form for an updated version of the package is facilitated thanks to the identification of new tests between package versions (~ git tags).

The workflow for the creation and the use of such validation form by the package will be demonstrated on R packages developed for interactive medical oversight reporting in R.

Speaker: Laure Cougnaud (Open Analytics NV)

pkg-validation-useR2026.pdf

144 rgamer: A package to help students learn game theory using R

We have developed rgamer, an R package for learning and applying game theory. The goal of rgamer is to support both teaching and learning by enabling students to explore game-theoretic concepts and instructors to demonstrate them effectively in R. The package not only solves standard models such as two-person normal-form games, but also provides visualizations that highlight key structural features. In addition to computing analytical solutions when available, rgamer offers numerical solutions for games in which closed-form solutions are difficult or impossible to derive. For example, users can define a normal-form game, display its payoff matrix, and compute pure- and mixed-strategy Nash equilibria. The package also visualizes best-response correspondences in two-person normal-form games and allows users to simulate repeated play. For extensive-form games, rgamer draws game trees, performs backward induction, and identifies subgame-perfect equilibria. It further includes tools for solving one-to-one and one-to-many matching problems. By automatically solving games under analysis, rgamer reduces the computational burden of game-theoretic modeling. This enables students to focus on interpretation and intuition rather than mechanical calculation, and relieves instructors of the need to devote substantial class time to solution techniques, giving them greater scope to develop conceptually important topics.

Speaker: Yuki Yanai (Kochi University of Technology)

rgamer

rgamer examples for useR! 2026

rgamer_poster_useR!2026.pdf

145 A Type System for the R Language

Dynamic programming languages are increasingly adopting explicit type annotations. Not only do they serve as documentation, but they also enable static type checking to eliminate entire classes of bugs and help tools provide a better development experience. In this talk, we will present our advancements in bringing types to R, including a type system with a static type checker with type inference.

R's flexibility and design for interactive use make it challenging to type statically. Our approach is built on the novel theory of set-theoretic types. This foundation allows us to natively support R's core structures, data frames, polymorphic functions, and classes. Rather than imposing rigid constraints, the system uses set operations to model practical behaviors. For example, intersection types can elegantly handle overloaded functions: a function annotated as $\texttt{(int -> int) & ({a:int} -> {b:int})}$ clearly documents that it returns an integer when given an integer, but returns a list with name $\texttt{b}$ when passed a list with name $\texttt{a}$.

Because spelling out every type can be tedious during rapid development, our constraint-solving inference engine deduces types automatically wherever possible. Additionally, the checker supports a subset of the C FFI, enabling the analysis of R packages that rely on native C or Fortran code.

Speaker: Dr Filip Křikava (Czech Technical University in Prague)

A Type System for the R Language.pdf

146 genMPGMM: A synthetic data generator with controlled feature partitions and cluster similarity for evaluating pattern discovery methods

We present a synthetic data generator for simulation studies in clustering and partition comparison. The generator creates datasets with controlled cluster structures and predefined similarity levels between alternative partitions, enabling systematic analysis of clustering algorithms' stability.

The framework uses a Gaussian mixture distribution and generates data through a three-stage procedure that introduces latent cluster structures. First, observations are partitioned into mixture components across multiple latent profiles with controlled similarity. Partition similarity is regulated using the Adjusted Rand Index (ARI), allowing precise control over agreement between cluster structures. Second, the geometric properties of mixture components are specified in the feature space. Component means are sampled, and the separation between components is controlled via Mahalanobis distance, to manage cluster overlap and clustering difficulty. Finally, observations are generated by sampling from multivariate normal distributions for each component.

The generator offers flexible control over key characteristics: number of observations, features, mixture components, latent profiles, component mixing proportions, and noise levels. This approach enables controlled simulation experiments for evaluating clustering and biclustering methods. By providing precise control over data characteristics and partition structures, it supports reproducible benchmarking under well-defined conditions.

Speaker: Karolina Widzisz (Department of Computer Graphics, Vision and Digital Systems, Silesian University of Technology, Gliwice, Poland)

KWidzisz_Poster_useR!_2026.pdf

147 Statistical Analysis and Visualization of Indian Development

This project offers a data-driven look at India’s socio-economic growth using the R programming language. The goal is to examine how key indicators like population, literacy rate, GDP growth, and other development measures have changed over time in various regions of India. By using publicly available datasets, the project employs statistical analysis and visualization techniques in R to turn raw data into clear visual stories.

Along with highlighting growth, the project also investigates the challenges and inequalities that come with development. While many indicators show notable national progress, the analysis uncovers differences in regional development, access to resources, and socio-economic opportunities.

Speaker: Prakhar Srivastava (Indian Institute of Information Technology Una)

finalPoster24514.pdf

Final Presentation R.pdf

Final Presentation R.pptx

Social: Gala Dinner

Thursday 9 July

08:00 Registration open

08:30 Coffee Break

Keynote: The Work Behind the Work: Sustaining R Through Community

Conveners: Heidi Seibold (Digital Research Academy), Kari L. Jordan

148 The Work Behind the Work: Sustaining R Through Community

Abstract
Every R script, package, and analysis rests on a foundation of community labor that often goes unseen. While R is widely celebrated for its technical power, its longevity depends just as much on the people who teach, maintain, translate, mentor, and organize around it.
In this keynote, I will draw on my leadership at The Carpentries to share stories and insights about building and sustaining global open-source communities. I will discuss how contribution shows up in many forms, how community care and governance shape technical ecosystems, and why investing in people is essential to the future of R.
This talk is an invitation to pause, reflect, and reimagine our relationship to the tools we use.
Whether you are an R package maintainer, educator, researcher, or new user, you will leave with a deeper understanding of how your participation matters and how giving back can strengthen both the R community and your own professional journey.
Bio
Dr. Kari L. Jordan, is a leading figure in data science education, serving as the Executive Director for The Carpentries, a globally recognized nonprofit organization. Upon completing Bachelor's and Master’s degrees in Mechanical Engineering from Michigan Technological University, she pursued a Ph.D. in Engineering Education at The Ohio State University,
specializing in interventions to enhance belonging for people of color in STEM. Dr. Jordan's visionary leadership has propelled The Carpentries' mission worldwide, fostering exponential growth and impact across academia, industry, and government sectors. A sought-after speaker and advocate for diversity and inclusion, she champions accessible data literacy and bridges the digital skills gap through strategic initiatives and international collaboration.
Dr. Jordan's dedication to empowering individuals and fostering inclusive learning environments has earned her widespread recognition and respect, shaping the future of data literacy for societal betterment.

Speaker: Kari L. Jordan

keynote_Jordan

10:00 Coffee Break

Talks: Bioinformatics and biostatistics

Convener: Torsten Hothorn (CH/DE)

149 Travel Paths: Bridging the usability gap in open source animal movement algorithms

The behavior ecology literature offers a rich library of approaches for finding patterns in animal movement data. While many of the biologists developing these algorithms publish their code, it is rarely optimized for reuse. Even well-designed packages with similar workflows have different interfaces that potential users need to learn one by one. By wrapping these algorithms in a standardized interface, the “Travel Paths” framework reduces researcher toil. Instead of digging through scripts and learning disparate conventions, they can run many methods with just a few functions. The framework is composed of two packages: the trackframe package provides a flexible and interoperable format for input data while the travelpaths package, taking inspiration from parsnip, offers the interface for movement models. In this talk, we’ll discuss how we designed this framework and how it can be leveraged to enable even novice R users to apply a variety of methods to their animal movement data.

Speaker: Mx Katrina Brock (Max Planck Institute of Animal Behavior)

20260709-brock-user-v1.html

20260709-brock-user-v2.html

brock-user2026.pdf

150 The TDAverse: Modular, interoperable, and extensible topological data analysis in R

Topological data analysis (TDA) is an emerging area of statistical research grounded in topology, intersecting with exploratory analysis, statistical inference, and machine learning. It is therefore important for R users to have access to comprehensive and reliable TDA tools.

Published R packages for TDA fall into three categories: First, {TDA} and {rgudhi} interface with comprehensive libraries in lower-level languages (GUDHI, Dionysus, PHAT). While they provide essential tools, they are not designed to integrate with common R workflows and are made fragile by the need to adapt to upgrades in both the source language and R. Second, {TDAstats}, {TDAkit}, {TDApplied}, and {GSSTDA} provide bespoke toolkits for inference, machine learning, and survival analysis. These tend to be designed for specialists, self-contained rather than modular, and syntactically inharmonious with common workflows—likely hindering adoption by non-specialists. Third, packages like {simplextree}, {interplex}, {ripserr}, and {tdaunif} each perform a narrow task. These have been developed by Dr. Brunson and colleagues with the goal of building a general-purpose, native, modular, and extensible R package collection for TDA. However, they are not yet as comprehensive or interoperable as envisioned.

We present developments accomplished thanks to an ISC grant from the R Consortium during the last year. Our goal was to integrate popular TDA techniques into common statistical workflows in R, with a special focus on the Tidymodels framework (Kuhn and Wickham 2020) for machine learning (ML) tasks.

ML relies heavily on vectorizations, and the last decade of TDA research has produced several for topological data. We developed {tdarec} to bring TDA features into tidymodels workflows. We also published {phutil} which, in the spirit of {tibble}, proposes a data structure to host persistence data and functions to compute distances between persistence diagrams.

TDA also relies on statistical inference. A variety of hypothesis tests have been proposed in the literature with idiosyncratic implementations. We published a first version of {inphr} for that purpose, aiming for future compatibility with tidymodels' {infer} package. Finally, we published an upgraded version of {ripserr} that makes the Ripser library, which efficiently computes Vietoris–Rips filtrations, available in R.

Speaker: Aymeric Stamm (Department of Mathematics Jean Leray, UMR CNRS 6629, Nantes University)

The TDAverse

151 The tractoverse: A unified collection of packages for microstructure-augmented connectivity analysis in R

Diffusion magnetic resonance imaging (MRI) is a non-invasive imaging technique that allows us to probe the microstructure in the brain at a mesoscopic scale by making the MR signal sensitive to the diffusion of water molecules in the brain, which is restricted or hindered by cellular structures such as axons or glial cells. Diffusion MRI suffers from a poor spatial resolution, which yields the use of mixture models to account for multiple tissue populations in each voxel. Many such models have been devised in the literature (see here) for an overview. Microstructure models can then be used to infer the structural connectivity by tracing so-called streamlines that follow the main directions of diffusion throughout the brain. This process is called tractography. Most of the literature so far has analysed either the microstructure or the connectivity separately, but there is a growing interest in combining both types of information to get a more complete picture of the brain's structure and function.

The vast majority of softwares for microstructure and connectivity analysis such as {dmipy}, {dipy} of {scilpy}, are implemented in Python and gather into a single package all the functionalities for microstructure and connectivity analysis, which makes them hard to maintain and extend on the development side and hard to use on the user side. In R, according to the Medical Image Analysis CRAN task view, the only currently available packages for microstructure and connectivity analysis are {dti} and {TractoR}, which share the same drawbacks as the Python packages and do not include ways to model microstructure-augmented connectivity (MAC).

The tractoverse aims to develop a unified collection of packages for MAC analysis in R, in which each package performs a single task and all interact seamlessly with each other. The tractoverse is currently in development, but we will give an overview of the main packages that will be included in the collection:

• {fiber}: provides a data structure for MAC data;
• {mascot}: provides easy access to recent macroscale structural connectomes of the Human brain obtained from diffusion MRI data through diffusion modeling and tractography;
• {midi}: provides tools to simulate the MR signal attenuation predicted by state-of-the-art microstructure models under different experimental conditions; the package comes with a companion Shiny app;
• {riot}: provides an R interface for importing and exporting tractography data to and from R;
• {rtists}: provides visualization tools for tissue integrity superimposed on tractography streamlines.

Speaker: Aymeric Stamm (Department of Mathematics Jean Leray, UMR CNRS 6629, Nantes University)

The tractoverse

152 On Balancing Numeric and Categorical Variables for Clustering

The package clustMixType [3] is one of the most popular packages for clustering of mixed-type data. Nonethless, an open issue not only for clustering mixed-type data but also for clustering in general is an appropriate weighting of the variables. In Huang’s original paper [1] as well as in the clustMixType package only heuristics are given for this purpose. In the presentation it will be discussed how the concept of variable importance can be used for cluster analysis [1] and how this can be further used to find an appropriate weighting of the variables. An R implementation will be demonstrated.

[1] Hennig, C. and Murphy, K. (2023). Quantifying Variable Importance in Cluster Analysis. Proc. CLADAG 2023, S.515-518, ISBN: ISBN: 9788891935632.
[2] Huang, Z. Extensions to the k-Means Algorithm for Clustering Large Data Sets with Categorical Values. Data Mining and Knowledge Discovery 2, 283–304. 1998, https://doi.org/10.1023/A:1009769707641.
[3] Szepannek, G. clustMixType: User-Friendly Clustering of Mixed-Type Data in R. The R Journal. 2018. https://doi.org/10.32614/RJ-2018-048

Speaker: Gero Szepannek (Stralsund university of Applied Sciences)

szepannek_upload.zip

Talks: Emerging trends in R

Convener: Peter Dalgaard

153 Moving towards R package 'Matrix' version 2.0-0

We present the history, structure, and design philosophy of "recommended" R package Matrix, which extends R with classes and methods for structured matrices having sparse or dense storage. We review recent and ongoing development in Matrix, covering matrices with integer or complex data, matrix factorizations, and improved documentation. Finally, as the number of reverse dependencies of Matrix on CRAN or Bioconductor passes 2000 (recursively, 12000), we discuss the enduring importance of Matrix within the broader R package ecosystem and highlight efforts to maintain backwards compatibility (or else break as little as possible, as slowly as possible).

Speaker: Mikael Jagan

Matrix2-MJ-MM.pdf

154 Juggling with S7

The throw sequence "423" is a valid pattern for juggling with three balls, but "432" will result in collisions and dropped balls. How can you tell? All juggling patterns can be described in a notation called siteswap, and siteswap sequences can be mathematically validated and visualised.

In this talk, I introduce jugglr, an R package for working with siteswap sequences. It validates sequences and prints their properties, generates timeline and ladder diagrams with ggplot2, and creates animated GIFs. You'll learn something about juggling. But this is an R conference, not a juggling convention, so more importantly, you'll learn about S7, the new(ish) Object Oriented Programming (OOP) system designed to combine the best of S3 and S4 whilst avoiding the pitfalls of each.

Juggling patterns turn out to be an ideal domain for S7. A siteswap's validity,
period, and number of props are all automatically derived from its throw sequence -- a natural fit for S7's computed properties. Input constraints like "a sequence must contain only alphanumeric characters" map directly to property validators. And the relationship between general siteswap patterns and specific types like vanilla, synchronous and multiplex siteswap is cleanly expressed through S7's class hierarchy and factory constructors.

Using S7 in a package is not yet well-documented, so I'll also share practical lessons from developing jugglr. You'll leave with both an appreciation for the mathematics of juggling and the confidence to use S7 in your own packages.

Speaker: Ella Kaye (University of Birmingham)

index.html

Juggling with S7

155 Metamorphoses: Transforming CVXR to S7 with an AI Agent

CVXR is the R implementation of CVXPY, a widely-used disciplined convex optimization framework. Maintained by two developers, the S4-based CVXR 1.0 had fallen significantly behind CVXPY in features. We report on a complete rewrite using S7 We report on a complete rewrite using S7, that is now on CRAN that targets current version of CVXPY. The new version is 4-5x faster than old CVXR and the rewrite was CRAN ready in 25 days, despite a full-day job. We share the architectural decisions that made this feasible -- isomorphic file trees, a 15-rule "constitution" governing the AI agent, annotation-based test mapping -- along with S7 pitfalls we encountered and honest performance data. Some of the strategies we adopted might be useful for others using AI agents for building R packages.

Speaker: Balasubramanian Narasimhan (Stanford University)

talk-standalone.html

156 Semantic vectors for safer statistics

Statistical analysis on temporal, spatial, graph, and probabilistic data is error-prone when the data types lack intrinsic structure. Outputs from models typically return these composite data types separately, requiring the user to assemble and apply the results correctly. This reduces the accessibility of statistics and results in error-prone analysis. Representing these data types using composite vector types makes statistical operations and data analysis easier.

In this talk, I will introduce the application of vectorised statistical operations across common dimensions not otherwise handled in traditional data structures. The vectors of vectors data type implemented in the vecvec R package is foundational for creating efficient mixed data types. The distributional and mixtime R packages leverage vecvec in order to create vectors that mix different distributions and temporal granularities together. Storing distributions with different shapes and parameterisations together in the same vector abstracts away the data handling complexity while providing a user-friendly interface for calculating distributional statistics such as the mean, quantiles, and densities. Similarly, storing time at different granularities allows combining data from different sources and facilitates forecasts across multiple levels of temporal aggregation.

These semantic vectors combine naturally in tidy rectangular data to facilitate statistically sensible multi-dimensional analysis. For instance, pairing temporal and distributional vectors yields a dataset ready for probabilistic time series forecasting, or pairing temporal and spatial vectors a dataset ready for spatio-temporal analysis.

Speaker: Mitchell O'Hara-Wild (Monash University)

user2026-vecvec.pdf

Talks: Machine learning, deep learning, and AI

Convener: Katarzyna Woźnica (Warsaw University of Technology, Systems Research Institute of the Polish Academy of Sciences)

157 Good Programming Practices, Design and Agile in the Era of AI-Generated Code

By 2026, the era of vibe coding has made rapid prototyping effortless; however, it has also highlighted a significant gap between demos and production-quality systems. While AI agents can simulate agile processes, they often optimise for speed at the expense of architectural integrity, security, and long-term technical debt. Anyone can generate code, but not everyone can manage a project. The real test is handling the shift in what stakeholders want while keeping the software safe and valid. This is why spec-driven development is now the most important skill for a professional R developer.

The developer’s role is evolving into that of a workflow architect who owns the entire communication loop. Beyond prompting, the engineer must lead review meetings and demos to translate stakeholder needs into a resilient technical specification. By embracing the tinyverse philosophy and prioritising clean design, we can build frameworks that are flexible enough to undergo constant inspect and adapt cycles without collapsing under their own weight. This approach ensures that we are not just shipping a single product but also establishing a robust, scalable production workflow.

The UCB package gridify (part of pharmaverse) serves as a practical example of this mindset. By utilising S4 classes and focusing on composition over inheritance, it provides a stable foundation that survives iterative changes while maintaining a minimalist dependency footprint. In a world of commodity code, the ability to bridge the gap from a stakeholder's needs to a validated production environment is the competitive advantage for the R community.

Speaker: Maciej Nasiński (UCB & University of Warsaw)

MaciejNasinski_UseR_2026.pdf

158 Advanced Machine Learning, Visualization, and Agentic AI using rtemis

Basic research and clinical medicine are increasingly capitalizing on data-driven approaches to derive insights into disease pathophysiology and discover new therapeutic targets. While advanced algorithms are readily available, their application requires a combination of domain, quantitative, and technical expertise, leaving them out of reach for many domain expert researchers and clinicians. The rtemis framework is a collection of packages that has been designed to make advanced machine learning, visualization, and agentic AI as efficient, flexible and accessible as possible.

The framework takes advantage of the S7 class system to provide a fully object-oriented backend including comprehensive type-checking and validation of all inputs and outputs, maximizing correctness and robustness. The user-facing API is functional and designed to offer the most user-friendly and efficient experience, significantly reducing the time and effort required to train and evaluate models regardless of user technical expertise. All algorithm configuration for supervised and unsupervised learning is performed using setup functions that generate S7 config objects, validated at input and providing comprehensive error messages.
A custom text formatting system supports output of ANSI-formatted text in the console and HTML-formatted text in web interfaces, as well as plain text output for logging. All messaging is handled by a custom logging system that includes datetime stamps, color-coded output and provenance. This provides essential transparency for complex pipelines where a single user call results in a complex cascade of internal function calls.

The framework has been successfully used for algorithm development, applied health data science, and machine learning training.

Speaker: Efstathios Gennatas (UCSF)

Machine Learning, Visualization,
 and Agentic AI
 for all with rtemis

rtemisAIML_useR_2026_GennatasEDco.pdf

Virtual Presentation Room

Convener: Maciej Szymkowski (Future Processing, Bialystok University of Technology)

159 Seeing Groups, Not Just Gradients: Supervised Class Differentiation to Better Interpret Beta Diversity

Ecological community data are inherently multivariate, and beta diversity is typically explored through unsupervised ordination (e.g., PCoA, NMDS). While these methods excel at revealing gradients of variance, they ignore a priori hypotheses about group structure. This talk introduces constrained ordination, specifically Canonical Analysis of Principal coordinates (CAP) and Linear Discriminant Analysis (LDA) as a supervised alternative for beta diversity. This shifting in the component orientations better aligns with showing which space is unique occupied but a class, the most common use case for beta diversity. I demonstrate how to project dissimilarity matrices onto axes that maximize separation among pre-defined groups (e.g., treatment types, habitats), thereby directly testing ecological hypotheses. This approach shifts the perspective from ordering components by descending variance to descending class distinction. All code and examples will be available in a GitHub Repo.

Speaker: Dr Nicholas Spyrison (Unaffiliated (employed by IFF))

2026-07-08_Spyrison_BetaDiversity.mp4

BetaSpaces_Presentation.html

160 Mapping Climate Stories with {sf}

Climate data has coordinates, but also powerful stories hiding in plain sight. In this talk, I’ll show the reasons why I feel in love with the R package {sf} while covering climate change in the Amazon as a freelance journalist. Every Last Drop is a project about oil exploration in the Amazon that showcases that spatial analysis doesn't need to be complicated. Just a handful of core functions and a few essential concepts make geospatial analysis surprisingly simple, even for users who are starting their R journey.

Speaker: Renata Hirota

Every Last Drop - Project website

mapping-climate-stories-with-sf.mp4

mapping-climate-stories-with-sf.pdf

161 Visual Explanations of XAI Explainers, to Gain Insight into Predictions from High-Dimensional Models

Understanding the behaviour of complex machine learning models has become a challenge in the modern day. Explainable AI (XAI) methods were introduced to provide insights into model predictions, however explaining these explanations can be difficult without proper visualisation methods. In addition, settling the disagreements between these explainers can be difficult based purely on numerical values without a proper visual indicator of the question each method is answering. To fill this gap we have built rosella, an R package offering an interactive Shiny app that visualises model behaviour in the data space alongside XAI explanations. Designed for developers, educators, and students, and based on layered approach towards XAI visualisation, rosella makes model decisions more accessible and interpretable.

Speaker: Janith Wanniarachchi (Monash University)

Github Repository for Slides

Presentation slides

user_2026_submission.mp4

162 Gamifying data visualisation: Teaching ggplot2 through competitive code golf

Code golf—writing the shortest possible code to solve a problem—has emerged as an engaging method for teaching programming fundamentals. Its competitive, game-like structure fosters student motivation and encourages self-directed learning.

Inspired by the success of CSSBattle, which attracts thousands of daily users with CSS challenges, I present ggplot battles: a new browser-based platform designed to teach data visualisation using R's ggplot2 package. Participants are given a target plot and a predefined dataset, then challenged to recreate the plot as closely as possible.

Built with WebR, the platform runs entirely in the browser with no local R setup required. I will discuss the learnings, challenges, and systems behind the website, and the pedagogical value it can add to the classroom.

Speaker: Michael Lydeamore (Department of Econometrics and Business Statistics, Monash University, Victoria, Australia)

ggplotbattles: Gamifying data visualisation

163 Exploring Global Stock Factors with R

Author Information
Name: Rituraj Singh
Affiliation: Indian Institute of Information Technology Una, Himachal Pradesh, India
Programme: B.Tech Computer Science Engineering (Data Science)
Email: 24519@iiitu.ac.in

Title
Do Some Stocks Always Beat Others? Exploring Global Stock Factors with R

Primary Topic
Finance and Economics Applications of R / Data Analysis and Visualisation

Keywords
factor investing, cross-sectional returns, momentum, global equities, R for finance

Abstract
Have you ever wondered why some stocks seem to do better than others, even when they appear equally risky? This is a question researchers have studied for decades, and the short answer is: a few simple patterns — called factors — explain a surprising amount of the difference.
This project uses a real-world dataset of 100 companies across 9 countries (Australia, Canada, China, France, Hong Kong, India, Japan, UK, and USA), covering 20 quarters from early 2019 to late 2023 (2,000 data points in total). Using R, I built and tested five such factors — market, size, value, momentum, and profitability — to see which ones actually worked over this period.
The key findings were: stocks earned about 8.9% more per year than keeping money in a savings account (the market premium); stocks that had gone up in the previous quarter continued to rise, earning an extra 2.6% per year (the momentum effect); and surprisingly, large companies actually beat small ones by 1.1% per year, going against the usual textbook prediction. The global fear index (VIX) had the strongest negative link with returns (r = -0.53), meaning when people panic, stocks fall sharply — as seen vividly in the COVID crash of early 2020.
This project is intended as a friendly introduction to factor investing using real data and straightforward R code.

Previous Presentations
This topic has not been presented at any previous conference.

External Resource
GitHub Repository: https://github.com/riturajsinghbisen/Global-Stocks-Factors
The repository includes:
The full dataset (GlobalStockFactors.csv) with 2,000 observations
R scripts
A README guide

Speakers: Dr Prince Sharma (Indian Institute of Information Technology Una), Rituraj Singh (Indian Institute of Information Technology Una)

Exploring Global Stock Factors with R.pdf

StockMarketRPSR.mp4

164 Ensemble Models for missing multi-omics data

Missing data is a common challenge in data analysis, particularly in multi-omics studies, where heterogeneous data sources and technical limitations often result in incomplete measurements. In these situations, predictive models may fail when some required variables are missing.

This presentation demonstrates ensemble learning strategies designed to improve prediction despite incomplete data. The approach combines multiple base classifiers into a single framework, allowing different models to capture complementary patterns in the data.

The talk focuses on selecting a diverse set of classifiers that can generate predictions even when some variables are missing. Two strategies will be presented: static ensemble selection, which incorporates a modified classifier disagreement metric, and dynamic ensemble selection, which adapts the choice of models to the pattern of missing values in previously unseen samples.

The methodology is part of the author’s PhD research and contributed to the development of the playOmics R package.

Speaker: Jagoda Głowacka-Walas

Ensemble Models for missing multi-omics data_JGW.mp4

Ensemble Models for missing multi-omics data_JGW.pptx

Talks: Teaching R / R in teaching

Convener: Katarzyna Woźnica (Warsaw University of Technology, Systems Research Institute of the Polish Academy of Sciences)

165 Playful Teaching of Simulation Models: From Monolithic Shiny Apps to Quarto Dashboards and webR

Quantitative modeling is essential in the life and environmental sciences, yet students often face significant barriers due to "math anxiety" and programming complexity. While differential equations are often perceived as dry or difficult, interactive simulations offer a playful entry point that fosters intuitive understanding. However, traditional "downloadable models" often suffer from software dependencies and lack of integrated documentation, creating technical hurdles that distract from learning.
Drawing on our experience of using our own CRAN packages for research and teaching, we present a pedagogical evolution that leverages R’s statistical and visualization capabilities to overcome these issues. We demonstrate how to integrate tutorial content directly with interactive tools using three complementary approaches:

1. Interactive Exploration: Shiny applications that embed instructional material, using climate trend visualization as an example.

2. Structured Dashboards: Using deSolve-backed simulators to teach population dynamics, resource limitation, and predator-prey interaction to secondary school educators and students.

3. Integrated Tutorials: Using WebAssembly/webR-enabled slides to provide interactive environments for classroom demonstrations and lab exercises.

Beyond specific case studies, we will discuss the technical transition from monolithic Shiny apps to modular Quarto dashboards and webR. This simplifies maintenance and allows for the seamless integration of narrative text and live code. Attendees will gain insights into designing educational tools that reduce entry barriers while opening the door to the full power of the R ecosystem.

Speaker: Thomas Petzoldt (TUD - Dresden University of Technology)

Slides: Playful Teaching of Simulation Models: From Monolithic Shiny Apps to Quarto Dashboards and webR

166 Teaching Reproducibility by Design: An End-to-End R Workflow Using Quarto, Open Data, and Package Development

Reproducibility in R is often taught as a final requirement rather than as a workflow that evolves over time. In many research methods courses, students write one-off scripts against artificial datasets, submit them, and never return to their code. This talk presents an alternative: an end-to-end, R-native ecosystem designed to move students from code users to reproducible researchers—and ultimately, to contributors.

I describe a multi-semester pipeline built around R Markdown, Bookdown, and Quarto in which students repeatedly revisit and refactor their own work. Homework assignments are written as R Markdown files and later consolidated into individual Bookdown portfolios, requiring students to debug, standardize, and improve earlier code. In subsequent iterations, both student portfolios and final research projects are migrated to Quarto, positioning modern publishing as a continuation of reproducible practice rather than a separate skill, and reinforcing the idea that reproducible research is iterative rather than disposable.

This workflow culminates in three interconnected open-access books: an instructor-authored reproducible research textbook, a cohort-level Quarto book containing student research chapters built on NYC Open Data, and individual student portfolio books that students can continue to update beyond the course.

To ground this work in real-world analysis, students conduct original research using NYC Open Data. Because API complexity and data access friction proved to be a major barrier, I developed nycOpenData, a CRAN package that enables any R user to access datasets from the NYC Open Data portal without writing custom API calls. This reduces infrastructure overhead and allows students to focus on research questions rather than data acquisition.

As a full-circle outcome, advanced students now contribute their own functions back to the same package they used for their analyses, gaining experience with package development, GitHub workflows, and collaborative software practices.

The talk concludes with design lessons, technical tradeoffs, and a reproducible template that R users can adapt for teaching, onboarding, or collaborative research across disciplines.

Speaker: Christian Martinez (CUNY)

The Accidental Author: Designing Reproducible Workflows that Outlive the Classroom

Lightning Talks

Convener: Peter Dalgaard

167 Making R a First-Class Environment for LLMs

R is an interactive environment. Working effectively with R means being able to interact with a live session to inspect objects, view and iterate on plots, access help, and step through running code in the debugger. Making LLMs effective in R therefore means more than giving them a way to execute code: it means exposing R’s interactive affordances in a form the model can use.

This talk introduces mcp-repl, an open-source front end to R that plugs into existing agents such as Claude and Codex. It provides a long-lived REPL with persistent state, in-band help, plot capture, support for debugger- and readline-based workflows, guardrails for large outputs, responsive handling of both interactive and long-running computations, and OS-level sandboxing. In practice, mcp-repl makes general-purpose coding agents much more capable at package development, Shiny debugging, and iterative analysis, especially in long-running autonomous tasks without a human in the loop.

Because mcp-repl plugs into existing agents, it also reflects the constraints of a plug-in architecture. To make that contrast concrete, this talk also looks at Posit Assistant as an example of what becomes possible when the interface is integrated into an IDE for data analysis and designed to keep the human in the loop.

Together, Posit Assistant and mcp-repl illustrate two ways to bring R’s interactive affordances to an LLM: one through an integrated experience designed for close human collaboration, the other through a plug-in front end designed for autonomous work in a private runtime.

Speaker: Tomasz Kalinowski (Posit PBC)

mcp-repl-lightning-talk.html

168 Evaluate Untrusted R Code Locally Isolated in a webR Sandbox?

The ability to execute arbitrary R code securely is becoming increasingly critical, e.g., for use cases ranging from AI agents executing LLM-generated code to peer-to-peer (P2P) compute clusters. Sandboxing techniques such as virtual machines and Linux containers are commonly used to isolate the host machine from untrusted code. Because these technologies can be complicated to set up, and often require administrative rights, they are less accessible to developers than desired. Originally designed for in-browser applications, WebAssembly has recently emerged as an alternative, cross-platform sandboxing environment on the local machine.

This talk introduces the rw package, which provides functions for evaluating untrusted R expressions in a locally running WebAssembly-and-Node-based webR environment. The evaluation is, by default, configured such that the R code does not have access to the filesystem, network, process tree, or memory. There are options for relaxing the isolation, e.g., giving the R sandbox access to select data directories on the host system and access to persistent R package libraries.

One of the driving factors for the rw project is to provide a tool for exploring how well the host system is isolated from the R code running in webR. What backdoors are available for R code to break out of the webR WebAssembly environment? If it is possible to break out of webR, how much of the host system can we access, if at all? If there are backdoors, can they be closed by updating the webR codebase? Or, do we need a full rewrite in order to use webR to secure the evaluation of untrusted R code? I am inviting the R community to discuss and investigate this area further.

If we can show that sandboxing via webR provides sufficient isolation, then it provides an alternative to traditional sandboxing techniques for evaluating untrusted R code. One immediate application for rw is in peer-to-peer (P2P) distributed computing, where workers can evaluate tasks from peers within a protected sandbox. An implementation of this concept is available in the future.p2p package, part of the Futureverse parallel ecosystem. Sandboxing via rw can also be useful for agentic AI development, where the agents evaluate potentially unsafe R code generated by a large language model (LLM). If it turns out that the isolation is insufficient for untrusted code, rw still provides a valuable tool for R developers to implement and test that their packages also work in webR running in the web browser.

Speaker: Henrik Bengtsson (Futureverse.org, R Foundation, R Consortium, Bioconductor, R anno 2000, University of California San Francisco (UCSF))

Evaluate Untrusted R Code Locally Isolated in a webR Sandbox?

Lightning Talks: Bioinformatics and biostatistics

Convener: Torsten Hothorn (CH/DE)

169 GO-a-GO: Gene Ontology enrichment analysis of gene pairs

The identification of overrepresented Gene Ontology (GO) terms in a set of genes is a standard approach to obtain functional associations, e.g. to characterize the set of differentially expressed genes between treatment and control samples. Here, we present the R package GO-a-GO that annotates Gene Ontology terms that are enriched in a given set of gene pairs. This provides the opportunity to annotate which functions are associated with gene pairs defined by a selected group of chromatin contacts, such as differential contacts between cell types or chromatin loops.

GO-a-GO calculates enrichment from a permutation test for overrepresentation of gene pairs that are associated with a shared GO term. Such gene pairs are counted for the original set of gene pairs and compared against randomized sets in which the structure of the pairs is preserved, but the gene identities (including the associated GO terms) are permuted. Therefore, we do not focus on the fact that the term is enriched in a group of genes, but that genes with this term get paired more often than expected.

We used GO-a-GO to identify GO terms enriched in gene pairs associated with human chromatin loops, revealing several enriched functional terms that were not enriched when annotating the gene set without the information on gene pairs. In summary, we developed a package to study the function of chromatin contacts, which integrates with the Bioconductor ecosystem and can be used independently on the type of experimental method used and the nature of contacts.

Speaker: Aleksander Jankowski (University of Warsaw)

Jankowski – GO-a-GO_ Gene Ontology enrichment analysis of gene pairs – useR! 2026.pdf

Lightning Talks: Teaching R / R in teaching

Convener: Katarzyna Woźnica (Warsaw University of Technology, Systems Research Institute of the Polish Academy of Sciences)

170 Teaching R with R. How to get started doing lectures with Quarto and reveal.js.

Traditional presentation software like PowerPoint or Keynote are commonly used for teaching, but not ideal for displaying and running code, as it involves a lot of copying and pasting. Moving to presenting Quarto documents makes it much easier to incorporate code and output in the presentation. But it can be daunting as it involves learning a new framework for creating and presenting slides.

In this talk I'll demonstrate how to use Quarto and reveal.js to run lectures heavy on R (or other programming languages). I'll draw on my experience from running a course for master's students on data wrangling this spring. We'll look at how to display and run code, how to create shareable pdfs of your slides and how to efficiently create exercise and answer sheets with fragments. We'll tame the beast that is image sizing and positioning, as well as making sure the text is sized and formatted well. At the end we dip our toes into .scss file to create your own personalised style.

This talk is designed to reduce the barrier to switching to a Quarto-focused presentation process. The source files will be made available on GitHub after the talk and can be used as a starting point for generating your own slides. The concepts I show are by no means exhaustive or the only way to create slides with Quarto, but they are a great way to get started.

Speaker: Dr Håvard R. Karlsen (NTNU)

hrk_teachingRwithR.html

hrk_teachingRwithR.pdf

171 Teaching R for Applied Economics: From Zero to Causal Inference

Our first session doesn't start with R. It starts with asking students to unzip a folder. Every year, some of them can't.
This is the reality of teaching empirical economics today. Students arrive having grown up on tablets and smartphones, fluent in apps but lost in a file system. Getting them to difference-in-differences feels, at first, impossibly far away.
And yet, that's exactly what we do in a single semester.
We'll share how we built a course that takes students with zero programming experience through the full journey: from navigating RStudio for the first time, to visualising data, to running regressions and thinking seriously about causality. Using the tidyverse with the fixest package as our central tools, we move step by step from cross-sectional correlations to panel regressions, instrumental variables, and difference-in-differences designs.
Along the way we picked up a few tricks. Green and red post-it notes to read the room without putting anyone on the spot. Supervised computer-lab exams instead of take-home group work: our answer to free-riding, and to a world where AI can answer your problem set in seconds.
The goal was never just syntax. It was to send students away able to sit down, open RStudio, interrogate a dataset, and approach causal claims with a healthy dose of scepticism.
We'll share what worked, what didn't, and what we wish we'd known earlier.

Speakers: Marta Bernardi (TU Dresden), Sarah Listabarth (TU Dresden)

260630-UseR.pdf

Keynote: Wrap Up & Farewell

Convener: Przemyslaw Biecek (Centre for Credible AI)

12:30 Lunch

Social: Warsaw Guided Tour