R is a popular language for statistical computing and data analysis, but it's often criticized for being slow, especially when processing large numerical datasets. The good news? Much of this perception comes down to how R code is written and what libraries it's linked to.

At the heart of R's numerical power is BLAS (Basic Linear Algebra Subprograms). When R code is written to leverage BLAS via vectorized operations, and linked to a high-performance BLAS implementation, the speedups can be dramatic.

This guide walks you through:

What is BLAS, and Why Does R Use It? 🔢

BLAS is a low-level specification for common linear algebra operations such as:

R delegates many of its core numeric functions to BLAS internally—meaning if your code uses these functions, it can benefit from a faster BLAS implementation without modification.

🧠 R Code Performance Starts with Vectorization

Before worrying about swapping BLAS libraries, the most critical optimization you can make is in how you write your R code. In particular:

Prefer Vectorized Code

Instead of using for loops to perform row-wise or element-wise operations, use R's built-in vectorized functions.

Slow (loop-based):

n <- 1000
x <- rnorm(n)
y <- rnorm(n)

z <- numeric(n)
for (i in 1:n) {
  z[i] <- x[i] + y[i]
}

Fast (vectorized):

z <- x + y

Use BLAS-backed Functions

Some key base R functions are backed by BLAS and can benefit directly from optimized libraries:

Operation Function
Matrix multiply A %*% B
Cross product crossprod(A)
Transposed cross tcrossprod(A)
Cholesky chol(A)
Solve linear sys solve(A, b)
Eigenvalues eigen(A)
Singular value svd(A)

By sticking to these functions and avoiding reinventing linear algebra with loops, you write cleaner, faster code that scales better on large problems.

Using Optimized BLAS Libraries with R 🧩

R comes with a reference BLAS that emphasizes compatibility and correctness over speed. But you can swap it for a faster implementation.

Popular BLAS Libraries

BLAS Library Notes
OpenBLAS Open source, fast, multi-threaded, widely available
Intel MKL Extremely fast, optimized for Intel CPUs
Apple Accelerate Default on macOS, good performance
ATLAS Automatically tuned, but less popular today

Tuning Thread Count for Multi-core BLAS ⚙️

Most optimized BLAS libraries are multi-threaded, which can significantly boost performance, if properly configured.

Set Number of Threads in R:

Sys.setenv(OMP_NUM_THREADS = 4)        # For OpenMP-based BLAS (OpenBLAS, MKL)
Sys.setenv(OPENBLAS_NUM_THREADS = 4)   # OpenBLAS-specific
🔧 Benchmark different values. Too many threads can actually slow down performance due to contention or memory bandwidth limits.

To force reproducibility (e.g. for research):

Sys.setenv(OMP_NUM_THREADS = 1)

Caveats: Stability and Reproducibility ⚠️

✅ Summary: Best Practices for High-Performance R Code

Here's your cheat sheet to fast R code:

Practice Benefit
Write vectorized code Clean, fast, memory-efficient
Use matrix operations (%*%, solve, crossprod) Taps into BLAS automatically
Avoid loops where possible Better cache locality, faster execution
Use optimized BLAS backend Up to 20x speedup with zero code change
Control threading Avoid oversubscription and improve reproducibility
Benchmark often Know when and where speed gains occur

🧵 Final Thoughts

R is often underestimated in terms of performance. But the real secret is not rewriting everything in C++ or relying on external libraries, it's about writing R code that vectorizes well, and making sure your environment is set up to let BLAS do the heavy lifting.

If you're doing heavy numerical computing, in bioinformatics, statistics, machine learning, or simulation modeling, investing a few hours to optimize your R setup and scripting style can translate to days of computation saved over time.

Questions or thoughts? Want to see a follow-up post on benchmarking or parallelism in R? Reach out at connect@puregradient.com.