An RSE learning environment
The flagship challenge of the hackathon is an open, discipline-overarching environment in which people learn research software engineering by doing it — with accounts, teams, submitted artefacts, feedback and peer review around the material, not just the material itself.
Parts of this exist. Oxford RSE’s Gutenberg is an open-source platform with accounts, courses and progress tracking, and it is the natural starting point rather than a competitor. What no platform yet does is close the loop between learners — group work, artefact submission, peer assessment — or run the exercise on the hardware RSE actually targets.
This page sets out what already exists, why general-purpose learning technology does not fit RSE, and the design questions we want to attack in Glasgow. None of them is settled — that is the point of the two days.
Why not just use a normal learning platform?
Learning technology has thirty years of standards and platforms behind it, and RSE should reuse every bit of it that fits. Three things do not fit.
Notebooks are not documents
The dominant RSE teaching format is the executable notebook — Jupyter, R Markdown, Quarto. Learning management systems assume a self-contained, assessable object: a page, a video, a quiz. A notebook is none of these; it is code that must run against a real environment before it means anything.
Compute is part of the exercise
An RSE assignment is frequently about the machine: a GPU kernel, an MPI job, a SLURM batch script, a container that has to build. You cannot embed “submit this to the cluster and account for your allocation” in a quiz engine.
Results must leave again
What a course produces — lessons, worked solutions, learner artefacts — should be publishable as open educational resources and as reusable notebooks. Today it is either locked inside a course shell or published as a static site with no environment around it.
What already exists — and what it does not cover
The offerings closest to ours, and the gap each one leaves.
| Environment | What it offers | What it does not cover |
|---|---|---|
| Gutenberg · Oxford RSE for UNIVERSE-HPC — GitHub, live at train.rse.ox.ac.uk RSE and HPC training |
The closest thing that exists: BSD-3 platform, self-hostable, with accounts, enrolment, pathway syllabi and results for course leaders. Content lives as Markdown in separate CC-licensed repos | The learner half of the loop: no group formation, submission or peer assessment. No execution back-end, no learning-object metadata |
| The Carpentries · Software, Data & Library Carpentry — GitHub Foundational computing skills |
Open community lessons, instructor training, a global workshop network | Lessons and workshops, not a running environment: no accounts, teams, submission or assessment |
| RSE-Mentopolis · RWTH Aachen / Klaus Tschira Foundation Sustainable research software |
The closest in ambition: lifecycle and stakeholder models plus teaching modules | Models and modules from one institution, not software others can deploy |
| KODAQS Toolbox · GESIS / Mannheim / LMU — built on andrew Social sciences: data quality |
Hands-on tutorials in an open aggregation hub, plus the blended KODAQS Academy | One discipline and topic, data analysis over software engineering; no group work |
| iBOTS / iBehave · University of Bonn — GitHub Neuroscience |
Self-paced tracks from Python and NumPy to Git and DataLad, as a static notebook site | One discipline, static: no accounts, groups, feedback or assessment |
Landscape as surveyed for the CHARTED dRTP proposal; all links checked 3 August 2026.
Two gaps follow, and they are exactly what the hackathon attacks:
- Coverage is siloed. Where teaching is hands-on, it is usually tied to one discipline’s research process or to one technology stack. Gutenberg is the instructive exception: it is discipline-neutral precisely because the content lives in separate repositories and only the engine is shared.
- The loop is only half closed. Gutenberg gets furthest — accounts, enrolment, completion and exercise results — but stops at what the instructor sees. None of these offerings covers group formation → artefact submission → structured feedback → peer assessment, so learners still never review each other’s code.
We build on this rather than duplicating it. Carpentries lessons and the KODAQS and iBOTS course structures are directly reusable inside such an environment — and Gutenberg is a serious candidate for the base itself: BSD-licensed, self-hostable, already carrying the accounts and course model, and missing exactly the pieces the hackathon sets out to prototype. “Extend Gutenberg” is a legitimate outcome of the two days, and arguably the cheapest route to a working thin slice.
The link to learning technology: standards
Underneath the gaps sits a question that predates this proposal and comes out of the RSE curriculum discussion: where should RSE learning material be stored, and in which format? The material we surveyed lives as executable notebooks and R Markdown rendered into static sites, or as plain Markdown in Git repositories — the andrew aggregator behind the KODAQS Toolbox executes Jupyter and R Markdown inside containers, the iBOTS platform is a static site with notebooks, Gutenberg pulls CC-licensed Markdown from separate repositories — while the learning-object metadata standards from learning technology are absent throughout. Not one of these platforms describes its material with LOM, SCORM or anything equivalent; discovery and reuse across institutions happen by reading READMEs.
IEEE LOM
Learning Object Metadata describes a resource so it can be found and reused across repositories. It is the natural candidate for an RSE OER index — but its educational vocabulary (interactivity type, typical learning time, semantic density) was written for documents, not for a code repository plus an environment specification.
SCORM / xAPI
Packaging and run-time tracking for self-contained courseware. SCORM assumes the object runs in the browser inside the LMS; an RSE exercise runs in a container, or on a cluster. xAPI is the more promising half: it can record statements about activity that happens outside the platform.
H5P
Rich interactive content types, open source and widely integrated into LMSs. Excellent for the conceptual layer of an RSE lesson; it has no notion of executing learner-supplied code against a real toolchain. Where is the boundary between an H5P element and a notebook cell?
The open question for the hackathon is therefore not which standard to adopt but whether any of them is applicable to RSE content at all, given that they assume self-contained, assessable objects rather than code that must run against a real environment — and, if the answer is “partly”, which profile or extension covers the rest.
The link to RSE requirements: real infrastructure
The other half of the problem is the one learning technology never had to solve. Gutenberg makes the point sharply: it was built for UNIVERSE-HPC, a curriculum explicitly about research software engineering for high-performance computing, by the RSE groups at Oxford, Southampton, Imperial and Edinburgh together with EPCC and the Software Sustainability Institute — and it still delivers material about HPC rather than running on it. The compute stays the learner’s problem. That is not an oversight in Gutenberg; it is the hard part everyone has deferred.
An RSE learning environment sits on top of research computing infrastructure, which means:
- Compute back-ends. Where do examples with GPU requirements run? Notebook services such as JupyterHub or BinderHub cover the small cases; teaching CUDA kernels or MPI means a real allocation on an HPC system, reached through a batch scheduler (SLURM) or a gateway such as Open OnDemand.
- Identity and access. University HPC access runs on federated identity and project allocations. An environment that hands out accounts has to reconcile that with how clusters actually admit users.
- Environments as artefacts. Containers, lockfiles and module systems are not deployment details here; reproducing the environment is part of the learning objective and part of what gets assessed.
- Languages. Python and R at minimum, as in andrew — but RSE teaching also needs compiled languages: C++, Fortran, Julia, and the build systems around them.
- Cost and fair use. Peer assessment means many people running each other’s code. Quotas, scheduling and cost control are design constraints from day one, not afterthoughts.
Open design questions for the two days
- Metadata standards. Is any learning-object metastandard (IEEE LOM, SCORM/xAPI, H5P) applicable to RSE content? What would an RSE application profile have to add?
- Architecture. Federated, so institutions keep and describe their own material — or component-based, with one platform and pluggable parts? Gutenberg has already picked an answer worth arguing with: shared engine, content in separate repositories.
- Runnable examples. Which languages must be supported, and in book-style or notebook-style form?
- Compute. Where do GPU and HPC examples run, and who pays for them?
- Integration. How does such an environment sit alongside the learning management systems universities already run — and alongside the GitLab/GitHub instances where the code already lives?
- Build on, or build new? Several groups have built their own platform — Gutenberg above all, and it is open source and self-hostable. What are their perks, can they be integrated rather than replaced, and is forking Gutenberg the fastest way to a working thin slice?
The modules page breaks these down into pieces small enough to build in two days, and says what we think the two days can realistically produce.
Bring an answer — or a better question
If you have built one of these, surveyed one of these, or have strong opinions about any of the six, come and say so on day 1.
Or join the Matrix room first.