Pre-arrival technical setup 🧰

Prepare and verify your computer before SSoQE 2026.

Please complete this setup before travelling to SSoQE 2026. No previous experience with R, Python, Git, or a command-line shell is assumed on this page. The first Tuesday lesson does assume that the setup has been completed. If one of the final checks fails, send us the report before the school so that we can help.

Pack your digital field kit 🌿

Think of this page as packing for fieldwork—but for your computer. Work through it one step at a time, tick off what works, and ask for help if something behaves strangely. You are not expected to know any of this already! ✨

At a glance 🗺️

🐚 Learn the difference between the R Console and a shell Terminal.
📊 Install R 4.5.x and the current RStudio Desktop release.
🛠️ Install Quarto and, on Windows, the Rtools version matching R 4.5.
🌱 Install Git, create a GitHub account, and sign in through a browser flow.
🐍 Install Python 3.10–3.14, connect it to RStudio, and install CPU PyTorch.
📥 Use the SSoQE script to download the latest 2026 lesson releases.
📦 Run the SSoQE preparation checks and keep the final report.
✅ Complete the manual final checks at the bottom of this page.

1. Meet the shell and Terminal 🐚

A shell is a text-based way to give commands to your computer. A Terminal is the window in which the shell runs. Windows normally uses PowerShell; macOS and Linux commonly use shells such as zsh or bash. For the simple commands on this page, they behave similarly.

RStudio contains two different places where you can type commands:

The R Console runs R code. Its prompt normally starts with >.
The Terminal runs shell commands such as git, quarto, and python.

Do not type the prompt symbols shown by the application. Type only the command after the prompt and press Enter.

Open a Terminal 🚪

In RStudio, choose Tools → Terminal → New Terminal, or open the Terminal tab beside the Console. You can also use Windows Terminal or PowerShell on Windows, Terminal on macOS, or your distribution’s Terminal application on Linux.

Try these harmless commands one at a time:

pwd
ls

pwd prints the folder in which the shell is currently working. ls lists its contents. To move into another folder, use cd followed by its path. Put quotation marks around a path containing spaces:

cd "Documents/SSoQE-2026"

Press the Up arrow to recall the previous command. Press Ctrl+C to stop a command that is still running. Read a command before pasting it: do not run commands you do not understand, especially commands that delete files or request administrator access.

R Console or Terminal? 🧭

# R Console: this is R code
R.version.string

# Terminal: these are shell commands
git --version
quarto --version
python --version

If the shell says that a command is not recognized or not found, the program is either not installed or not available on the shell’s PATH. Restart RStudio after installing software before trying again.

2. R, RStudio, Quarto, and Rtools 📊

Install R 4.5.x from CRAN, then install RStudio Desktop. R is the language; RStudio is the interface in which we will write and run R code. The RStudio user guide is the authoritative reference if installation or first launch behaves unexpectedly.

Install Quarto. Quarto is separate from RStudio and is used to render several SSoQE presentations, exercises, and reports.

Windows participants should also install the Rtools release matching R 4.5. macOS and Linux users do not install Rtools; use the platform-specific build tools described by CRAN only if the preparation report says they are needed.

Restart RStudio. Run the first line in the R Console and the second line in the Terminal:

R.version.string

quarto --version

3. Git and GitHub 🌱

Install Git 💾

Install Git, restart RStudio, and verify the installation in the Terminal:

git --version

Required: create your GitHub account now 🪪

After installing Git, create a free account at GitHub.com. Do not continue until you can sign in to the account in your browser: the account is needed to request private-material access and participate in the collaboration exercises.

Choose a professional username that you will be comfortable using in scientific work. Add an email address you can access and verify it when GitHub sends the confirmation message. An institutional email can also make you eligible for GitHub Education.

Git and GitHub are related but different: Git is the program installed on your computer; GitHub is the online service and account used to share Git repositories.

Introduce yourself to Git 👋

Git records a name and email with your work. Use the same verified email address as your GitHub account. Open the Terminal and substitute your own details:

git config --global user.name "Your Name"
git config --global user.email "you@example.org"

Verify the saved values without changing them:

git config --global user.name
git config --global user.email

The last two commands should print the identity you entered. They do not change it.

Check Git from R with `{usethis}` 🔎

The SSoQE preparation script installs {usethis}. After completing Section 6, return to this check and run the following in the R Console:

usethis::git_sitrep()

git_sitrep() reports whether R and RStudio can find Git, which name and email Git will use, and whether GitHub credentials are available. Read the report; do not worry if it contains more detail than you recognize.

If the report shows the wrong identity, set it from the R Console as an alternative to the Terminal commands:

usethis::use_git_config(
  user.name = "Your Name",
  user.email = "you@example.org"
)

The related usethis::use_git() function initializes Git inside the current R Project. It is useful later, but it is not a general installation check: run it only when you deliberately want to place that specific project under version control.

Sign in securely 🔐

GitHub requires authentication for private repositories and for operations such as pushing changes. Your GitHub website password cannot be used as the password for HTTPS Git operations. There are two supported routes; use the browser-managed route first, then create a PAT if the R checks show that one is still needed.

Route A: browser-managed credentials 🌐

GitHub recommends GitHub CLI or Git Credential Manager for remembering HTTPS credentials. Current Git for Windows includes Git Credential Manager; it opens a browser login when an authenticated Git operation is first required. GitHub CLI provides a similar browser flow through gh auth login and can configure Git to use its credential helper. When one of these helpers supplies a credential to Git and gh::gh_whoami() succeeds, you do not need to create or paste a PAT manually.

Follow GitHub’s platform-specific credential-helper instructions, complete the browser login, and then run the {usethis} checks below after Section 6.

Route B: PAT for R and HTTPS 🔑

If usethis::git_sitrep() or gh::gh_whoami() says that no GitHub token is available, create a Personal Access Token from the R Console:

usethis::create_github_token()

Review the requested permissions and expiration on GitHub before generating the token. Copy the token once, return to the R Console, and store it through the secure Git credential prompt:

gitcreds::gitcreds_set()

Paste the token only into that prompt. Do not put it in a script, .Renviron, a Discussion post, email, chat, screenshot, or preparation report. The current {usethis} credential guide explains why the Git credential store is preferred over a plain-text environment file.

Verify the result:

usethis::git_sitrep()
gh::gh_whoami()

gh::gh_whoami() should print your GitHub username. If browser-managed credentials already made this check pass, do not create an additional PAT merely for this setup.

4. Python, RStudio, and CPU PyTorch 🐍

Install a 64-bit Python version from 3.10 through 3.14 using the official Python downloads. During a Windows installation, enable the option that adds Python to PATH. A GPU is not required for SSoQE.

The Posit guide to Python in RStudio explains that RStudio connects to Python through the R package reticulate. It also explains how RStudio discovers Python installations and environments.

After installing Python, restart RStudio and open Tools → Global Options → Python. Select the Python interpreter you installed. If several interpreters are listed, choose the one whose version matches the following Terminal command:

python --version

On Windows, try py -3 --version if python --version is not found. The SSoQE preparation script installs reticulate; after that, this R Console command shows the interpreter R will use:

reticulate::py_config()

Install CPU PyTorch 🔥

Use the selector on the official PyTorch installation page and choose your operating system, Pip, Python, and CPU. Run the command it provides in the Terminal. Using the official selector avoids prescribing a CUDA build that may not match your computer.

Use python -m pip rather than a bare pip command when possible. This makes it clearer which Python installation receives the package. Verify Python and PyTorch in the Terminal:

python --version
python -c "import torch; print(torch.__version__); print(torch.rand(2, 2))"

The second command should print a PyTorch version and a small two-by-two tensor. On Windows, replace python with py -3 in both commands if necessary.

5. Download the latest SSoQE 2026 lesson releases 📥

Each lesson will be distributed as a published GitHub Release. The SSoQE script contains the authoritative list of the 18 scheduled lesson repositories. For each repository, it downloads the most recently published full release whose case-sensitive tag contains ssoqe-2026. Tags such as ssoqe-2026-v1 and course-ssoqe-2026-final match; release titles do not affect selection. Drafts, prereleases, differently capitalized tags, and releases for other years are not selected.

Check access to private repositories first 🔒

Some materials may be private while they are being prepared. Request and confirm access before running the downloader:

Go to the SSoQE access discussion and comment with your GitHub username.
Wait for the organisers to grant access, then accept the invitation sent by GitHub.
Sign in to GitHub in your browser and confirm that you can open the private repository.

The downloader installs the {gh} package if needed and uses the GitHub credential available to R. Public repositories work without a token, but private lessons can be queried and downloaded only after gh::gh_whoami() succeeds and the reported account has repository access. If a private lesson still reports FAIL, confirm your invitation and credentials. As a fallback, open that repository’s Releases page while signed in, find the most recently published full release whose tag contains ssoqe-2026, download its course-material archive or source ZIP, and extract it inside materials_dir. The later prepare_ssoqe(materials_dir) step will discover it there.

Do not send passwords, authentication codes, or access tokens to the organisers or post them in a Discussion.

First download prepare_ssoqe.R to a location you can find, such as Downloads. Open RStudio, run the following line in the R Console, and select the downloaded script in the file chooser:

source(file.choose())

Choose where the lesson materials should live. This cross-platform example creates SSoQE-2026 inside your home folder:

materials_dir <- 
  file.path(
    path.expand("~"),
    "SSoQE-2026"
  )

Inspect the lesson list and perform a dry run. A dry run reports planned work without using the network or creating files:

ssoqe_lesson_manifest()

download_report <- 
  download_ssoqe_materials(
    materials_dir,
    dry_run = TRUE
  )

When the list looks correct, download the materials:

download_report <- 
  download_ssoqe_materials(materials_dir)

The downloader derives the release year from your computer’s current system date, so no yearly code change is required. On this 2026 page, the expected token is ssoqe-2026; an organiser can still request another year explicitly with an argument such as year = 2027.

The downloader queries GitHub’s release list, using your R credential when one is available. It validates archive paths before extraction and places each release in a versioned folder such as SSoQE-Our_Way_of_R_and_Reproducibility-ssoqe-2026-v2. It never overwrites or deletes an existing folder. The file ssoqe-active-releases.csv records which automatically downloaded folder is current for each lesson. If a teacher publishes a newer matching release, rerun the downloader: it keeps the older folder but makes the new one active, and the preparation step ignores inactive copies.

LESSON_NOT_AVAILABLE is accompanied by the message “There is no lesson data to download yet.” It means that the repository is reachable with your current access but the teacher has not yet published a matching full release. This is not a technical failure; rerun the downloader later. FAIL is reserved for problems such as an inaccessible repository, network error, invalid release metadata, or unsafe archive. In both cases, the downloader continues with the remaining lessons and never substitutes material from another year.

Save the report if any row says FAIL or LESSON_NOT_AVAILABLE:

utils::write.csv(
  download_report,
  file.path(materials_dir, "ssoqe-download-report.csv"),
  row.names = FALSE
)

6. Prepare R packages and lesson projects 📦

The same script contains the audited 2026 global R package manifest. That list is a convenient baseline; each lesson’s renv.lock remains authoritative for the exact versions used by that lesson.

Start with a dry run in the R Console:

report <- 
  prepare_ssoqe(
    materials_dir = materials_dir,
    dry_run = TRUE
  )

# When the dry run looks correct:
report <- 
  prepare_ssoqe(materials_dir)

The script checks required software and Git identity, installs missing packages from their documented source, discovers current downloaded projects with renv.lock, and restores each project in an isolated R process. It records PASS, FAIL, WARN, SKIP, DRY-RUN, or LESSON_NOT_AVAILABLE as appropriate, continues after a failure or unavailable lesson, skips work already completed, and verifies that restoration did not change any lockfile.

Running the script again is safe. Already installed packages and synchronized project libraries are reported and skipped. Save the report if you need help:

utils::write.csv(
  report,
  file.path(materials_dir, "ssoqe-preflight-report.csv"),
  row.names = FALSE
)

Audited global package manifest 📋

The manifest was assembled from direct package use in the active 2026 programme repositories. It includes shared workflow and teaching infrastructure plus the ecology, spatial, ordination, reporting, and deep-learning packages used directly by lessons. All current global entries are installed from CRAN. Packages needed only by a particular project can remain exclusive to that project’s renv library.

Inspect the self-contained manifest after sourcing the script:

ssoqe_package_manifest()

7. Final verification ✅

Before travelling, confirm all of the following:

You can identify whether a command belongs in the R Console or Terminal.
The download and preparation reports contain no unresolved FAIL or LESSON_NOT_AVAILABLE rows.
RStudio opens and reports R 4.5.x in the Console.
quarto check succeeds in the Terminal.
git config --global user.name and git config --global user.email return your identity.
gh::gh_whoami() prints your GitHub username in the R Console.
python -c "import torch; print(torch.rand(2, 2))" prints a small tensor.
RStudio’s Python settings point to the intended Python interpreter.
At least one downloaded lesson opens as an R Project.
For a lesson with renv.lock, renv::status() reports that the project is synchronized.

Need Help? 🆘

If you encounter problems, please ask before travelling:

Rerun download_ssoqe_materials(..., dry_run = TRUE) or prepare_ssoqe(..., dry_run = TRUE) and copy the failing rows.
Record your operating system, R version, and the exact error message.
Search or ask in the SSoQE questions forum.
Include what you tried and which step of this page you reached, but never include passwords, authentication codes, or access tokens.

We would much rather troubleshoot before the school than spend the first practical session installing software.

Common fixes are to restart RStudio after installing R, Quarto, Git, or Python; check whether you typed a shell command into the Terminal rather than the R Console; avoid cloud-synchronized folders when they cause file-locking errors; and check that security software has not blocked the programs. Do not delete renv.lock, edit it by hand, or replace a lesson’s project library with the global package library.

See you at SSoQE 2026! 🎉