What we will work on

The hackathon will focus on practical, community-led work across the Tidyomics ecosystem. Possible projects include:

• fixing bugs and closing issues across Tidyomics packages
• implementing new features and workflow improvements
• improving documentation, tutorials, and vignettes
• developing examples that make tidy omics workflows easier to learn and reuse

The Tidyomics open challenges board will be the main source of ideas for the hackathon. Before the event, please browse the board and identify problems or projects you would like to work on.

How to participate

Please start from the Tidyomics Hackathon Turku 2026 GitHub repository. The repository includes event details, preparation steps, and space for participants to open or discuss hackathon issues.

Before the event:

1. Browse the Tidyomics open challenges.
2. Select a problem you are interested in.
3. Open an issue in the hackathon repository, or comment/react if an issue already exists.
4. Join the community discussion in the EuroBioC2026 Turku hackathon Zulip channel.

Groups and projects will be finalised during the first day, based on open issues, participant interest, and available expertise.

Communication

The official discussion space for the hackathon is the EuroBioC2026 Turku hackathon channel on the Bioconductor Zulip server. The virtual meeting room link will also be shared through that channel and by email.

If you are attending EuroBioC2026 online, note that the conference provides free live streaming for remote participants.

People

The hackathon was proposed by Nicholas Cooley.

The organising committee is:

• Juan Henao
• Stevie Pederson
• Michael Love
• Nicholas Cooley

See you there

EuroBioC2026 is an opportunity to bring the Bioconductor and Tidyomics communities together around shared tools, shared challenges, and shared documentation. We hope to see you in Turku, on Zulip, and in the hackathon repository.

Motivation and design principles

This benchmark supports ongoing work to improve the performance of tidySummarizedExperiment. In this benchmark, we show up to 30x improvement in operations such as mutate().

The current optimisation is grounded in three principles:

• Decompose operation series: break mutate(a=..., b=..., c=...) into single operations for simpler handling and clearer routing. Reference implementation in R/mutate.R (decomposition step) at L146.
• Analyse scope: infer whether each expression targets colData, rowData, assays, or a mix (noting that the current analyser is likely over-engineered and could be simplified). See L149.
• Route mixed operations via plyxp: when an expression touches multiple slots, prefer the plyxp path for correctness and performance. See L155.

These design choices aim to preserve dimnames, avoid unnecessary tibble round-trips, and provide predictable performance across simple and mixed-slot scenarios.

Example of code optimisation

This was the mutate() method before optimisation. The previous implementation relied on as_tibble() |> dplyr::mutate() |> update_SE_from_tibble(.data)

The function update_SE_from_tibble interprets the input tibble and converts it back to a SummarizedExperiment. Although this step provides great generality and flexibility, it is particularly expensive because it must infer whether columns are sample-wise or feature-wise.

mutate.SummarizedExperiment <- function(.data, ...) {
    # Legacy implementation of mutate() for SummarizedExperiment:
    # - Validates requested edits against special/view-only columns
    # - Performs mutate() via tibble round-trip, then reconstructs the SE
    # Check that we are not modifying a key column
    cols <- enquos(...) |> names()
    
    # Deprecation of special column names:
    # capture all quoted args to detect deprecated special-column usage
    .cols <- enquos(..., .ignore_empty="all") %>% 
        map(~ quo_name(.x)) %>% unlist()
    if (is_sample_feature_deprecated_used(.data, .cols)) {
        # Record deprecated usage into metadata for backward compatibility
        .data <- ping_old_special_column_into_metadata(.data)
    }
    
    # Identify view-only/special columns (sample/feature keys, etc.)
    # Use a small slice to reduce overhead while probing structure
    special_columns <- get_special_columns(
        # Decrease the size of the dataset
        .data[1:min(100, nrow(.data)), 1:min(20, ncol(.data))]
    ) |> c(get_needed_columns(.data))
    
    # Are any requested targets among special/view-only columns?
    tst <-
        intersect(
            cols,
            special_columns
        ) |> 
        length() |>
        gt(0)

    if (tst) {
        columns <-
            special_columns |>
                paste(collapse=", ")
        stop(
            "tidySummarizedExperiment says:",
            " you are trying to rename a column that is view only",
            columns,
            "(it is not present in the colData).",
            " If you want to mutate a view-only column,",
            " make a copy and mutate that one."
        )
    }

    # If Ranges column not in query, prefer faster tibble conversion
    # Skip expanding GRanges columns when not referenced
    skip_GRanges <-
        get_GRanges_colnames() %in% 
        cols |>
        not()
    
    # Round-trip: SE -> tibble -> dplyr::mutate -> SE
    .data |>
        as_tibble(skip_GRanges=skip_GRanges) |>
        dplyr::mutate(...) |>
        update_SE_from_tibble(.data)
}

The new implementation captures all easy cases, such as sample-only and feature-only metadata mutate(). If mutate() is a mixed operation that can be factored out to sample- and feature-wise operation it is handled by plyxp. Otherwise, the general solution is used.

Key components to compare: - The pre-optimization code always uses a tibble round-trip (as_tibble() |> dplyr::mutate() |> update_SE_from_tibble()). - The optimized code first analyzes scope (colData, rowData, assay, or mixed) and dispatches to specialized paths. - The fallback still exists (mutate_via_tibble) for complex cases, preserving generality.

mutate.SummarizedExperiment <- function(.data, ...) {

       # Check if query is composed (multiple expressions)
    if (is_composed("mutate", ...)) return(decompose_tidy_operation("mutate", ...)(.data))

        # Check for scope and dispatch elegantly
        scope_report <- analyze_query_scope_mutate(.data, ...)
        scope <- scope_report$scope

        result <-
        if(scope == "coldata_only") modify_samples(.data, "mutate", ...)
        else if(scope == "rowdata_only") modify_features(.data, "mutate", ...)
        else if(scope == "assay_only") mutate_assay(.data, ...)
        else if(scope == "mixed") modify_se_plyxp(.data, "mutate", scope_report, ...)
        else mutate_via_tibble(.data, ...)

        # Record latest mutate scope into metadata for testing/introspection
        meta <- S4Vectors::metadata(result)
        if (is.null(meta)) meta <- list()
        meta$latest_mutate_scope_report <- scope_report
        S4Vectors::metadata(result) <- meta

        return(result)

}

Benchmarking Overview

This vignette benchmarks a set of mutate(), filter(), select(), and distinct() scenarios (see documentation) comparing performance before and after optimisation, by explicitly checking out specific commits via git worktree, loading each commit’s code with devtools::load_all(), running the same scenarios multiple times, and comparing the runtimes with ggplot boxplots.

• Before optimisation: commit 87445757d2d0332e7d335d22cd28f73568b7db66
• After optimisation: commit 9f7c26e0519c92f9682b270d566da127367bcbc0

suppressPackageStartupMessages({
  library(ggplot2)
  library(dplyr)
  library(SummarizedExperiment)
  library(rlang)
  library(devtools)
  library(airway)
  library(microbenchmark)
  library(reactable)
  library(patchwork)
})

load_branch_code <- function(worktree_dir) {
  if (!requireNamespace("devtools", quietly = TRUE)) stop("Please install devtools to run this vignette.")
  # Debug: print the directory we're looking for
  cat("Looking for worktree directory:", worktree_dir, "\n")
  cat("Directory exists:", dir.exists(worktree_dir), "\n")
  cat("Current working directory:", getwd(), "\n")
  # Check if directory exists
  if (!dir.exists(worktree_dir)) {
    stop(paste("Worktree directory does not exist:", worktree_dir))
  }
  suppressMessages(devtools::load_all(worktree_dir, quiet = TRUE))
}

create_airway_test_se <- function() {
  suppressPackageStartupMessages(library(airway))
  data(airway)
  se <- airway
  se[1:200, ]
}

benchmark_scenarios <- function() {
  list(
    coldata_simple_assignment = quo({ se |> mutate(new_dex = dex) }),
    coldata_arithmetic = quo({ se |> mutate(avgLength_plus_5 = avgLength + 5) }),
    coldata_concat = quo({ se |> mutate(sample_info = paste(cell, dex, SampleName, sep = "_")) }),
    coldata_grouped_mean = quo({ se |> group_by(dex) |> mutate(avgLength_group_mean = mean(avgLength)) |> ungroup() }),
    assay_simple_assignment = quo({ se |> mutate(counts_copy = counts) }),
    assay_plus_one = quo({ se |> mutate(counts_plus_1 = counts + 1) }),
    assay_log = quo({ se |> mutate(log_counts_manual = log2(counts + 1)) }),
    complex_conditional_coldata = quo({ se |> mutate(length_group = ifelse(avgLength > mean(avgLength), "longer", "shorter")) }),
    complex_nested = quo({ se |> mutate(complex_category = ifelse(dex == "trt" & avgLength > mean(avgLength), "treated_long", ifelse(dex == "untrt", "untreated", "other"))) }),
    mixed_assay_coldata = quo({ se |> mutate(new_counts = counts * avgLength) }),
    multiple_simple_assay = quo({ se |> mutate(normalized_counts = counts / 1000, sqrt_counts = sqrt(counts)) }),
    chained_mutates = quo({ se |> mutate(tmp = avgLength * 2) |> mutate(flag = ifelse(tmp > mean(tmp), 1, 0)) }),

    # Filter benchmarks (scoped and non-rectangular)
    filter_coldata_simple = quo({ se |> filter(dex == "trt") }),
    filter_coldata_numeric = quo({ se |> filter(avgLength > median(avgLength)) }),
    filter_assay_nonrect = quo({ se |> filter(counts > 0) }),

    # Select benchmarks (covering colData-only, rowData-only, assays-only, mixed)
    select_coldata_simple = quo({ se |> select(.sample, dex) }),
    select_rowdata_simple = quo({ se |> select(.feature) }),
    select_assay_only = quo({ se |> select(counts) }),
    select_mixed_keys_counts = quo({ se |> select(.sample, .feature, counts) }),
    select_coldata_wide = quo({ se |> select(.sample, dex, avgLength, SampleName) }),

    # Distinct benchmarks (covering colData-only, rowData-only, assays-only, mixed)
    distinct_coldata_simple = quo({ se |> distinct(dex) }),
    distinct_coldata_multiple = quo({ se |> distinct(dex, avgLength) }),
    distinct_rowdata_simple = quo({ se |> distinct(.feature) }),
    distinct_assay_only = quo({ se |> distinct(counts) }),
    distinct_mixed_keys_counts = quo({ se |> distinct(.sample, .feature, counts) }),
    distinct_coldata_wide = quo({ se |> distinct(.sample, dex, avgLength, SampleName) }),
    distinct_with_keep_all = quo({ se |> distinct(dex, .keep_all = TRUE) }),
    distinct_complex_expression = quo({ se |> distinct(dex, avgLength) })
  )
}

run_one <- function(expr_quo, reps = 5L) {
  se_base <- create_airway_test_se()
  mb <- microbenchmark::microbenchmark(
    eval_tidy(expr_quo),
    times = reps,
    setup = { se <- se_base },          # reuse the same input, avoid recreating inside the timed expr
    control = list(warmup = 2L)
  )
  # microbenchmark returns nanoseconds; convert to milliseconds
  as.numeric(mb$time) / 1e6
}

run_all_scenarios <- function(branch_label, reps = 7L) {
  scenarios <- benchmark_scenarios()
  out <- list()
  for (nm in names(scenarios)) {
    tms <- run_one(scenarios[[nm]], reps = reps)
    out[[length(out) + 1L]] <- data.frame(
      branch = branch_label,
      scenario = nm,
      replicate = seq_along(tms),
      elapsed_ms = tms,
      stringsAsFactors = FALSE
    )
  }
  bind_rows(out)
}

# Parallel version: run each scenario on a separate worker
run_all_scenarios_parallel <- function(branch_label, reps = 20L, workers = 1L, initializer = NULL) {
  scenarios <- benchmark_scenarios()
  nms <- names(scenarios)
  old_plan <- future::plan()
  on.exit(future::plan(old_plan), add = TRUE)
  future::plan(future::multisession, workers = workers)
  res <- future.apply::future_lapply(nms, function(nm) {
    if (!is.null(initializer)) initializer()
    tms <- run_one(scenarios[[nm]], reps = reps)
    data.frame(
      branch = branch_label,
      scenario = nm,
      replicate = seq_along(tms),
      elapsed_ms = tms,
      stringsAsFactors = FALSE
    )
  }, future.seed = TRUE)
  dplyr::bind_rows(res)
}

# Worktree directories (already exist in the post directory)
wt_before <- ".__bench_before__"
wt_after <- ".__bench_after__"

# Verify worktrees exist
if (!dir.exists(wt_before)) {
  stop("Worktree directory does not exist: ", wt_before)
}
if (!dir.exists(wt_after)) {
  stop("Worktree directory does not exist: ", wt_after)
}

# Before optimisation (commit 87445757)
load_branch_code(wt_before)

Looking for worktree directory: .__bench_before__ 
Directory exists: TRUE 
Current working directory: /Users/a1234450/Documents/GitHub/tidyomicsBlog/posts/2025-10-25-tidySummarizedExperiment-optimization 

res_before <- run_all_scenarios(branch_label = "before_optimization", reps = 10L)

# After optimisation (commit 9f7c26e)
load_branch_code(wt_after)

Looking for worktree directory: .__bench_after__ 
Directory exists: TRUE 
Current working directory: /Users/a1234450/Documents/GitHub/tidyomicsBlog/posts/2025-10-25-tidySummarizedExperiment-optimization 

res_after <- run_all_scenarios(branch_label = "after_optimization", reps = 10L)

results <- dplyr::bind_rows(res_before, res_after) |>
  dplyr::mutate(operation = dplyr::case_when(
    grepl("^filter", scenario) ~ "filter",
    grepl("^select", scenario) ~ "select",
    grepl("^distinct", scenario) ~ "distinct",
    TRUE ~ "mutate"
  ))

summary_table <- results |>
  group_by(branch, scenario) |>
  summarise(median_ms = median(elapsed_ms), .groups = "drop") |>
  tidyr::pivot_wider(names_from = branch, values_from = median_ms) |> 
  dplyr::mutate(speedup = round(before_optimization / after_optimization, 2))

Visualize with combined performance plots

dodge_w <- 0.7

p_box <- ggplot(results, aes(x = scenario, y = elapsed_ms, fill = branch)) +
  geom_boxplot(position = position_dodge(width = dodge_w), width = 0.7, outlier.shape = NA) +

  # Add jittered points aligned with the dodged boxplots
  geom_point(
    position = position_jitterdodge(jitter.width = 0.1, jitter.height = 0, dodge.width = dodge_w), 
    alpha = 0.6, 
    size = 0.5
  ) +
  scale_y_log10() + 
  coord_flip() +
  facet_grid(operation ~ ., scales = "free_y", space = "free_y") +
  annotation_logticks(sides = "b") +
  labs(title = "Performance comparison: Before vs After optimization",
       x = "Scenario",
       y = "Elapsed (ms)") +
  theme_bw() +
  
  # Angle x labels  
  theme(legend.position = "top", axis.text.x = element_text(angle = 45, hjust = 1))

# Speedup summary panel (median before/after ratio)
speedup_plot_data <- summary_table |>
  dplyr::mutate(operation = dplyr::case_when(
    grepl("^filter", scenario) ~ "filter",
    grepl("^select", scenario) ~ "select",
    grepl("^distinct", scenario) ~ "distinct",
    TRUE ~ "mutate"
  ))

p_speedup <- ggplot(
  speedup_plot_data,
  aes(x = speedup, y = reorder(scenario, speedup))
) +
  geom_col(width = 0.7, fill = "grey70", color = "grey40") +
  facet_grid(operation ~ ., scales = "free_y", space = "free_y") +
  labs(
    title = "Median speedup by scenario",
    x = "Speedup (before/after, x)",
    y = NULL
  ) +
  theme_bw() +
  theme(legend.position = "none")

combined_plot <- p_box + p_speedup + patchwork::plot_layout(widths = c(2.3, 1))
combined_plot

# Save the combined figure
ggsave("benchmark_plot.png", plot = combined_plot, width = 14, height = 8)

Session Info

R version 4.5.3 (2026-03-11)
Platform: x86_64-apple-darwin20
Running under: macOS Sonoma 14.6.1

Matrix products: default
BLAS:   /Library/Frameworks/R.framework/Versions/4.5-x86_64/Resources/lib/libRblas.0.dylib 
LAPACK: /Library/Frameworks/R.framework/Versions/4.5-x86_64/Resources/lib/libRlapack.dylib;  LAPACK version 3.12.1

locale:
[1] en_US.UTF-8/en_US.UTF-8/en_US.UTF-8/C/en_US.UTF-8/en_US.UTF-8

time zone: Australia/Adelaide
tzcode source: internal

attached base packages:
[1] stats4    stats     graphics  grDevices utils     datasets  methods  
[8] base     

other attached packages:
 [1] tidySummarizedExperiment_1.19.7 tidyr_1.3.2                    
 [3] testthat_3.3.2                  ttservice_0.5.3                
 [5] patchwork_1.3.2                 reactable_0.4.5                
 [7] rlang_1.1.7                     microbenchmark_1.5.0           
 [9] airway_1.30.0                   SummarizedExperiment_1.40.0    
[11] Biobase_2.70.0                  GenomicRanges_1.62.1           
[13] Seqinfo_1.0.0                   IRanges_2.44.0                 
[15] S4Vectors_0.48.0                BiocGenerics_0.56.0            
[17] generics_0.1.4                  MatrixGenerics_1.22.0          
[19] matrixStats_1.5.0               dplyr_1.2.0                    
[21] ggplot2_4.0.2                   devtools_2.4.6                 
[23] usethis_3.2.1                  

loaded via a namespace (and not attached):
 [1] tidyselect_1.2.1    viridisLite_0.4.3   farver_2.1.2       
 [4] S7_0.2.1            fastmap_1.2.0       lazyeval_0.2.2     
 [7] digest_0.6.39       plyxp_1.4.3         lifecycle_1.0.5    
[10] ellipsis_0.3.2      magrittr_2.0.4      compiler_4.5.3     
[13] tools_4.5.3         yaml_2.3.12         data.table_1.18.2.1
[16] knitr_1.51          S4Arrays_1.10.1     labeling_0.4.3     
[19] htmlwidgets_1.6.4   pkgbuild_1.4.8      DelayedArray_0.36.0
[22] RColorBrewer_1.1-3  pkgload_1.5.0       abind_1.4-8        
[25] withr_3.0.2         purrr_1.2.1         desc_1.4.3         
[28] grid_4.5.3          fansi_1.0.7         scales_1.4.0       
[31] cli_3.6.5           rmarkdown_2.30      ragg_1.5.1         
[34] remotes_2.5.0       otel_0.2.0          rstudioapi_0.18.0  
[37] httr_1.4.8          sessioninfo_1.2.3   cachem_1.1.0       
[40] stringr_1.6.0       XVector_0.50.0      vctrs_0.7.1        
[43] Matrix_1.7-4        jsonlite_2.0.0      systemfonts_1.3.2  
[46] crosstalk_1.2.2     plotly_4.12.0       glue_1.8.0         
[49] reactR_0.6.1        stringi_1.8.7       gtable_0.3.6       
[52] tibble_3.3.1        pillar_1.11.1       htmltools_0.5.9    
[55] brio_1.1.5          R6_2.6.1            textshaping_1.0.5  
[58] rprojroot_2.1.1     evaluate_1.0.5      lattice_0.22-9     
[61] memoise_2.0.1       SparseArray_1.10.9  xfun_0.56          
[64] fs_1.6.7            pkgconfig_2.0.3    

Behind the scenes

How does omicslog operate? In essence, for every function you apply to a SummarizedExperiment object, it tracks changes in rows and columns and records a message describing those changes in a dedicated logging structure stored in the object’s metadata.

Let us suppose we want to filter the airway dataset to retain only samples treated with dexamethasone (dex == "trt"):

result1 <- airway |> filter(dex == "untrt")

How many samples did we keep? Let us find out:

remaining_samples <- length(colData(result1)$Sample)
remaining_samples

#> [1] 4

What about the removed data? How many samples were discarded?

samples_removed <- length(colData(airway)$Sample) - length(colData(result1)$Sample)
samples_removed

#> [1] 4

It is often useful to express this change as a percentage, since we may be discarding a substantial amount of information:

percentage <- round(100 - samples_removed / length(colData(airway)$Sample) * 100,2)
percentage

#> [1] 50

At this point, we have a clear idea of how much the dataset has been modified. However, in practice, we often need to retrieve this kind of information repeatedly. To avoid manual bookkeeping, we would like to store it directly in the object itself, using the metadata slot.

Before doing so, we need some additional context, such as when the operation was executed and which function was used:

time <- Sys.time()
func <- "filter"

The most straightforward way to persist this information is to create a concise log message:

result1@metadata$log_history <- paste(time, func,": removed", samples_removed, "samples", "(", percentage,"%)", remaining_samples, "samples remaining")
result1@metadata$log_history

#> [1] "2025-12-17 13:27:34 filter : removed 4 samples ( 50 %) 4 samples remaining"

Column-related operations follow the same logic. For example, let us remove the albut column, as we are not interested in samples treated with albuterol:

result2 <- result1 |>
  select(!albut)

Even though we know that exactly one column was removed, it is still valuable to keep track of how the dataset was modified, when the change occurred, and which function was responsible:

columns_removed <- ncol(colData(result1)) - ncol(colData(result2))
columns_remaining <- ncol(colData(result2))
percentage <- 100 - round(ncol(colData(result2)) / ncol(colData(result1)) * 100,2)
time <- Sys.time()
func <- "select"

result1@metadata$log_history <- c(result1@metadata$log_history,
paste(time, func,": removed", columns_removed, "(", percentage,"%)", columns_remaining, "column(s) remaining")
)
result1@metadata$log_history

#> [1] "2025-12-17 13:27:34 filter : removed 4 samples ( 50 %) 4 samples remaining"
#> [2] "2025-12-17 13:28:38 select : removed 1 ( 11.11 %) 8 column(s) remaining"

As shown above, we extract the same type of information and append a new log entry to the metadata slot, just as we did for the row-based operation.

Too much work for a single data transformation? We agree. This is exactly where omicslog comes in—handling all logging operations automatically, so you can focus on the analysis.

We need your feedback!

Besides the messages shown above, what other operation details might you be interested in logging for an omics-oriented project?

Don’t hesitate to open an issue in the omicslog GitHub repo.

Introduction

The tidyomics ecosystem was born from a common challenge faced by life-scientists: omics technologies and frameworks in R often require specialised data structures and syntax. Switching from bulk RNA-seq to single-cell, or from expression data to genomic ranges, often felt climbing a different mountain. Tidyomics keeps the underlying objects exactly the same while giving them a single, tidyverse-flavoured grammar and data display making moving from bulk RNA-seq to single-cell or spatial data seamless. Its design principles take inspiration from the tidyverse philosophy of clear, human-readable code as articulated by Wickham et al. (2019) (JOSS 10.21105/joss.01686).

This initiative snowballed into an international collaboration—and ultimately into tidyomics (Nat. Methods 2024). Thanks to support from the Chan Zuckerberg Initiative’s Essential Open Source Software for Science (EOSS) Cycle 6 program, we are actively improving tidyomics through performance optimization, enhanced documentation, and ecosystem expansion to better serve the biomedical research community.

What is Tidyomics?

tidyomics is an open project to develop and integrate software and documentation to enable a tidy data analysis framework for omics data objects (Hutchison et al. 2024). The development of packages and tutorials is organized around tidyomics open challenges. Tidyomics enables the use of familiar tidyverse verbs (select, filter, mutate, etc.) to manipulate rich data objects in the Bioconductor ecosystem. Importantly, while the data objects are not modified, tidyomics provides a tidy interface to work on the native objects, leveraging existing Bioconductor classes and algorithms.

tidyomics is a set of R packages by an international group of developers. The ecosystem allows for code such as:

single_cell_data |>
  filter(Phase == "G1") |>
  ggplot(aes(UMAP_1, UMAP_2, color=score)) + 
  geom_point()

(filter single cells in G1 phase and plot UMAP coordinates)

or

chip_seq_peaks |>
  filter(FDR < 0.01) |>
  join_overlap_inner(promoters) |>
  group_by(promoter_type) |>
  summarize(ave_score = mean(score))

(compute average score by the type of promoter overlap for significant peaks)

At the same time, data containers can be abstracted as flat tibbles, closing the loop, and allowing the user extended visibility and operability of data.

For example, the airway dataset.

From the standard summarised representation

library(airway)
data(airway)
airway

class: RangedSummarizedExperiment 
dim: 63677 8 
metadata(1): ''
assays(1): counts
rownames(63677): ENSG00000000003 ENSG00000000005 ... ENSG00000273492
  ENSG00000273493
rowData names(10): gene_id gene_name ... seq_coord_system symbol
colnames(8): SRR1039508 SRR1039509 ... SRR1039520 SRR1039521
colData names(9): SampleName cell ... Sample BioSample

Loading tidyprint (available from the 3.22 Bioconductor release), the SummarizedExperimenrt is abstracted to a richer flat representation, without altering its internal properties or structure.

library(tidyprint)
airway

# A SummarizedExperiment-tibble abstraction: Features=63677 | Samples=8 | Assays=counts
#                                  |----------------- COVARIATES ---------------|
        .feature  .sample | counts | SampleName cell  dex   albut Run   avgLength
        <chr>     <chr>   | <chr>  | <fct>      <fct> <fct> <fct> <fct> <chr>    
1      ENSG0000… SRR103… | 679     | GSM1275862 N613… untrt untrt SRR1… 126      
2      ENSG0000… SRR103… | 0       | GSM1275862 N613… untrt untrt SRR1… 126      
3      ENSG0000… SRR103… | 467     | GSM1275862 N613… untrt untrt SRR1… 126      
4      ENSG0000… SRR103… | 260     | GSM1275862 N613… untrt untrt SRR1… 126      
5      ENSG0000… SRR103… | 60      | GSM1275862 N613… untrt untrt SRR1… 126      
        --------  ------- - ------ - ---------- ----  ---   ----- ---   ---------
509412 ENSG0000… SRR103… | 0       | GSM1275875 N061… trt   untrt SRR1… 98       
509413 ENSG0000… SRR103… | 0       | GSM1275875 N061… trt   untrt SRR1… 98       
509414 ENSG0000… SRR103… | 0       | GSM1275875 N061… trt   untrt SRR1… 98       
509415 ENSG0000… SRR103… | 0       | GSM1275875 N061… trt   untrt SRR1… 98       
509416 ENSG0000… SRR103… | 0       | GSM1275875 N061… trt   untrt SRR1… 98       
# ℹ 14 more variables: Experiment <fct>, Sample <fct>, BioSample <fct>,
#   `|` <|>, gene_id <chr>, gene_name <chr>, entrezid <chr>,
#   gene_biotype <chr>, gene_seq_start <chr>, gene_seq_end <chr>,
#   seq_name <chr>, seq_strand <chr>, seq_coord_system <chr>, symbol <chr>

Core Packages

Before diving into the individual packages you can simply load the meta-package and immediately gain access to all tidyomics functionality:

# BiocManager::install("tidyomics")  
library(tidyomics)  

With a single call you have a tidy interface ready for spatial, single-cell, bulk, and genomic range data.

Analysis Packages (non-core packages)

The core adapters above focus on data representation; the packages below provide high-level analysis grammars that build on those tidy foundations.

Publications

Hutchison W.J., Keyes T.J., et al. (2024). “The tidyomics ecosystem: enhancing omic data analyses.” Nature Methods 21, 1166–1170. DOI 10.1038/s41592-024-02299-2

This community paper introduces tidyomics and demonstrates its scalability on 7.5 million PBMCs from the Human Cell Atlas.

Community

Tidyomics is more than code — it is a lively community of developers, users and code-curators who collaborate across academic labs, core facilities and industry groups on five continents. Developers extend the toolbox, users pressure-test new ideas on real datasets, and curators keep documentation and tutorials clear and current. No matter whether you write R every day or are about to analyse your first sequencing experiment, you’ll find mentors ready to help — and eager to learn from your perspective.

library(tidyverse)
library(tidybulk)
library(tidySummarizedExperiment)

data(airway, package = "airway")
airway |>
  keep_abundant(factor_of_interest = dex) |>
  scale_abundance() |>
  test_differential_abundance(~ dex) |>
  filter(abundant) |>
  arrange(desc(abs(logFC)))

library(plyranges)
library(tidyverse)

Example workflow (requires genomic data)
granges |>
  filter(score > 10) |>
  join_overlap_inner(promoters) |>
  group_by(gene_id) |>
  summarize(mean_score = mean(score))

library(tidySingleCellExperiment)
library(tidyverse)

sce |>
  filter(Phase == "G1") |>
  ggplot(aes(UMAP_1, UMAP_2, color=score)) + 
  geom_point()

Future Directions

To conclude..

The tidyomics ecosystem represents a significant advancement in omics data analysis, providing a consistent, intuitive, and powerful framework for biological data analysis across multiple domains including transcriptomics and genomics. By bringing the principles of tidy data to omics, the ecosystem makes complex biological analyses more accessible, reproducible, and enjoyable.

Whether you’re a seasoned bioinformatician working with transcriptomics or genomics data, or just starting your journey in omics analysis, the tidyomics ecosystem provides the tools and resources you need to analyze your data effectively and efficiently.

The ecosystem continues to grow with new packages and capabilities being developed through the tidyomics open challenges, ensuring that the community drives the development of tools that meet real-world needs.

Join the community, contribute to the ecosystem, and help shape the future of tidy omics!

For more information, visit the tidyomics GitHub organization or follow us on Zulip.