ArchR: Single-Cell ATAC-seq Analysis in R

ArchR is a free, MIT-licensed R package for processing and analyzing single-cell ATAC-seq (scATAC-seq) data, developed in the Greenleaf Lab. This page is a compact path from installation to a first clustered UMAP, with the meaning of each command and how to read what it produces. It is written for lab and computational-biology researchers who already have scATAC-seq fragment files and a Linux or macOS machine.

What ArchR is used for in research

ArchR takes scATAC-seq fragment files and turns them into quality-filtered cells, doublet scores, a low-dimensional embedding, clusters and a UMAP. Per the Nature Genetics paper that describes it, the package also supports doublet removal, clustering, a unified peak set, trajectory analysis, peak-to-gene links, transcription-factor footprinting and integration with scRNA-seq (Granja, Corces et al., 2021, Nature Genetics 53:403-411). The official site describes it as a “full-featured R package for processing and analyzing single-cell ATAC-seq data” (archrproject.com, read 2026-11-08). For the wider context of combining chromatin, RNA and other layers, see multi-omics: definition, data layers and integration.

Install or access (official source only)

ArchR is supported on Unix-based systems (macOS and Linux). The official documentation states it is not supported on Windows or other operating systems, so Windows users need a Linux environment. It depends on devtools and BiocManager; MACS2 is highly recommended for peak calling. On macOS, the documentation also calls for a current gfortran and XQuartz, and some dependencies need GSL. The documentation recommends renv for managing package versions.

The official installation commands are:

if (!requireNamespace("devtools", quietly = TRUE)) install.packages("devtools")
if (!requireNamespace("BiocManager", quietly = TRUE)) install.packages("BiocManager")
devtools::install_github("GreenleafLab/ArchR", ref="master", repos = BiocManager::repositories())
library(ArchR)
ArchR::installExtraPackages()

If R was installed through conda, run Sys.setenv(CONDA_BUILD_SYSROOT="/") before install_github. Source: archrproject.com, read 2026-11-08.

Step-by-step: Arrow files to a first UMAP

The official tutorial uses a hematopoiesis example dataset of roughly 0.5 GB. Each step below uses the tutorial’s own commands.

1. Set threads.

   addArchRThreads(threads = 16)

   Match the number to your machine; it controls parallel processing in later steps.

2. Get the input fragment files.

   inputFiles <- getTutorialData("Hematopoiesis")

   For your own data, inputFiles is a named vector of fragment file paths.

3. Create Arrow files.

   ArrowFiles <- createArrowFiles(
     inputFiles = inputFiles,
     sampleNames = names(inputFiles),
     filterTSS = 4,
     filterFrags = 1000,
     addTileMat = TRUE,
     addGeneScoreMat = TRUE
   )

   filterTSS and filterFrags set the minimum TSS enrichment and fragment count per cell. The tutorial advises not setting the TSS cutoff too high at this stage because it can be raised later. addTileMat and addGeneScoreMat add the tile and gene-score matrices.

4. Score doublets.

   doubScores <- addDoubletScores(
     input = ArrowFiles,
     k = 10,
     knnMethod = "UMAP",
     LSIMethod = 1
   )

   Doublet scores are computed per cell and stored; cells are not yet removed.

5. Build the ArchR project.

   proj <- ArchRProject(
     ArrowFiles = ArrowFiles,
     outputDirectory = "HemeTutorial",
     copyArrows = TRUE
   )

   copyArrows = TRUE is recommended so an unaltered copy of the Arrow files is kept.

6. Filter doublets.

   proj <- filterDoublets(ArchRProj = proj)

   This does not delete anything from the Arrow files; the project simply ignores the flagged cells.

7. Reduce dimensionality.

   proj <- addIterativeLSI(
     ArchRProj = proj,
     useMatrix = "TileMatrix",
     name = "IterativeLSI"
   )

   Iterative latent semantic indexing on the TileMatrix gives the embedding that clustering and UMAP use.

8. Cluster.

   proj <- addClusters(input = proj, reducedDims = "IterativeLSI")

   Clustering runs on the IterativeLSI reduction.

9. Compute the UMAP.

   proj <- addUMAP(ArchRProj = proj, reducedDims = "IterativeLSI")

   The UMAP is stored in the project.

10. Plot.

    p1 <- plotEmbedding(ArchRProj = proj, colorBy = "cellColData", name = "Sample", embedding = "UMAP")
    p2 <- plotEmbedding(ArchRProj = proj, colorBy = "cellColData", name = "Clusters", embedding = "UMAP")

    Colour by sample and by cluster.

The full manual covers each stage in its own chapter, including Arrow files, doublet inference, the ArchRProject, iterative LSI, clustering (using Seurat’s FindClusters or scran), UMAP, and peak calling with MACS2 or the TileMatrix (archrproject.com/bookdown, read 2026-11-08). Follow the manual’s peak-calling chapter for the exact peak-set commands. For how graph-based clustering behaves and how to tune it, see Leiden clustering for single-cell data.

Output and how to read it

• Arrow files hold the per-sample data (fragments, tile matrix, gene-score matrix). The ArchRProject is the object you work with; it points to the Arrow files and holds cell metadata, reductions and embeddings.
• TileMatrix vs GeneScoreMatrix. The TileMatrix is the genome-tiled accessibility matrix used here as input to iterative LSI; the GeneScoreMatrix summarizes accessibility around genes as a proxy for gene activity.
• Doublet filtering is non-destructive. If cell counts drop after filterDoublets, the flagged cells are only ignored by the project, not removed from disk.
• Check the two UMAPs. Coloured by Sample, clusters that separate by sample rather than by biology suggest a batch effect to examine. Coloured by Clusters, you inspect whether the clusters form coherent groups. This is an interpretive check, not a pass/fail test.
• Exports. The manual’s chapter on handling output describes exporting fragments, matrices, SummarizedExperiment objects and bigWig files for use in other tools.

Troubleshooting

• Install fails on Windows. Windows is not supported by the official documentation; run ArchR on Linux or macOS.
• Conda R install errors. Set Sys.setenv(CONDA_BUILD_SYSROOT="/") before devtools::install_github, as the installation page instructs.
• Missing helper packages. Run ArchR::installExtraPackages() after loading the library.
• Peak calling fails. MACS2 is highly recommended and must be installed and reachable; the manual’s peak-calling chapter covers the setup.
• macOS build problems. Check for a current gfortran and XQuartz; some dependencies need GSL.
• Version drift. The documentation recommends renv, and the manual’s chapter 2 covers dependency management with renv and Docker.
• Run time and memory. Set addArchRThreads to match your machine. The Nature Genetics paper reports analysis of more than 1.2 million cells within 8 hours on a standard Unix laptop, which indicates the design target rather than a guarantee for your data.

Free alternatives

Other open-source packages cover scATAC-seq analysis. Choose by the language and ecosystem your lab already uses, and consult each project’s own documentation for features and supported platforms.

Tool	Language
ArchR	R
Signac	R
SnapATAC2	Python
EpiScanpy	Python

To get an R environment running without a local install, see RStudio on the cloud. Budgeting for the sequencing itself is covered in the single-cell sequencing cost guide.

FAQ

What is ArchR?

A free, MIT-licensed R package for processing and analyzing single-cell ATAC-seq data, from fragment files through clustering and UMAP to peak calling and footprinting.

Does ArchR run on Windows?

No. The official documentation states that it is supported on Unix-based systems (macOS and Linux) and not on Windows or other operating systems.

Does ArchR need MACS2?

MACS2 is highly recommended for peak calling according to the official installation page. The manual also describes a TileMatrix-based route.

How do I cite ArchR?

Granja JM, Corces MR, et al. ArchR is a scalable software package for integrative single-cell chromatin accessibility analysis. Nature Genetics 2021;53:403-411.

Does filterDoublets delete cells?

No. It does not delete cells from the Arrow files; the project ignores the flagged cells.

Sources

• ArchR official site, read 2026-11-08.
• ArchR official tutorial, read 2026-11-08.
• ArchR full manual, read 2026-11-08.
• Granja JM, Corces MR, et al. (2021). Nature Genetics 53:403-411.