SYCL Academy: a teachable SYCL curriculum with slides and exercises

A curriculum built as self-contained modules

SYCL Academy is described as a set of learning materials for SYCL heterogeneous programming, and the repository states that it provides materials that can be used for teaching SYCL.

The design intent is stated in the curriculum section. It is divided up into a number of short lessons consisting of slides for presenting the material and a more detailed write-up, each accompanied by a tutorial for getting hands-on experience with the subject matter. Each of the lessons is designed to be a self-contained module in order to support both academic and training style teaching environments.

That last clause is the important one. The materials were made to be handed to a lecturer or a training lead who needs to teach a topic in an afternoon without building a course from scratch, and the lesson boundaries are chosen so a module can be dropped into an existing syllabus.

The topic sequence is the curriculum in miniature. Lesson 01 is What is SYCL, 02 Enqueueing a Kernel, 03 Managing Data, 04 Handling Errors, 05 Device Discovery, 06 Data Parallelism, 07 Introduction to USM, 08 Using USM, 09 Asynchronous Execution, 10 Data and Dependencies, 11 In Order Queue, 12 Advanced Data Flow, 13 Multiple Devices, 14 Image Convolution, 15 Coalesced Global Memory, 16 Vectors, 17 Local Memory Tiling, 18 Further Optimisations, 19 Matrix Transpose, 20 More SYCL Features and 21 Buffer Accessor Model.

There is a lesson 00 called Fast Track with slides only, which is presumably a compressed path through the material, and the ordering tells you the shape of the progression. It starts with the single-device, buffer-based model, moves through USM as the alternative memory model, then into the scheduling and dependency questions that come with asynchronous execution, and only then into performance work on memory coalescing, vectorisation and local memory tiling.

The primary language listed is HTML, the licence is Creative Commons Attribution Share Alike 4.0 International, the default branch is main, and the published site is khronosgroup.github.io/syclacademy.

Slides and exercises live in two parallel trees

The physical layout mirrors the teaching design, and it is worth knowing before you clone anything.

The lectures are written in reveal.js and can be found in Lesson_Materials, in the sub-directory for each topic. To view them you open the index.html file in your browser. The browser's Full Screen mode runs the presentation, and the right and left cursor keys move forward and backward through it.

That is a deliberately low-friction arrangement. A lecturer clones the repository on the machine hooked to the projector, opens one file, and presents. There is no build step, no PDF export requirement and no plugin to install, and the reveal.js dependency is declared in package.json at version 6.0.1 for anyone who wants to work on the slides locally.

The exercises are separate, in Code_Exercises in the sub-directory for each topic. Each exercise has a markdown document instructing what to do, a source file to start with and a solution file to provide an example implementation to compare against.

The three-part exercise structure is the part that makes this usable in a classroom. The markdown is the brief, the starter source removes the blank-page problem so students work on the SYCL concept rather than on boilerplate, and the solution gives you something to compare against when a student is stuck or when you want to show the idiomatic form afterwards.

Lesson 00 and lesson 21 have slides but no exercise listed in the curriculum table, and lesson 21 is notable because Buffer Accessor Model comes last. That ordering suggests the accessor model is treated as the historical baseline that the rest of the material contrasts against, with USM introduced earlier at lessons 07 and 08 as the model most new code uses.

The table also lists slides, exercise, source and solution as separate link columns for every lesson from 01 to 20, which means each topic has all four artefacts, not just a subset.

Cloning the repository and opening the first deck

Getting the material is a single recursive clone, and the recursion is required rather than optional.

git clone --recursive https://github.com/KhronosGroup/syclacademy.git

The README says the required submodules are included in the clone, and the repository tree confirms there is a .gitmodules file plus an External/ directory for content that comes from elsewhere. If you clone without the recursive flag, the slides will have missing assets.

After the clone, the workflow for a lecturer is to open Lesson_Materials, pick the topic sub-directory, and open index.html in a browser. For a student, it is to open the matching directory in Code_Exercises and read the markdown brief first.

There is more in the tree than the two teaching directories. Scripts/ and Utilities/ hold the build tooling for the code exercises, Static/ holds shared assets, js/ holds the JavaScript used by the slides, and there are Python scripts at the top level including generate-curriculum.sh, which is what produces the curriculum table in the README from the directory contents.

The exercises are built rather than interpreted, which is where the CMake option comes in. The project has a CMakeLists.txt at the root and a generate-curriculum.sh script, and the build is controlled by the SYCL_ACADEMY_ENABLE_ONEAPI_LESSONS CMake option.

The repository also carries a REUSE.toml and a LICENSES/ directory, plus SPDX headers in the source. That is the mechanism for complying with the share-alike licence across a repository that mixes its own material with third-party content, and it is worth understanding if you intend to reuse the slides in your own course materials.

The oneMath lessons and the implementation they assume

The curriculum continues past lesson 21 into a section the README marks as oneMath, and the caveat attached to it is the most practically important line in the document.

The README says the lessons in that table work with oneAPI, but might not work with other SYCL implementations. As a result they are only built by default when doing a DPC++ build of SYCL-Academy, and whether to build them can be controlled through the SYCL_ACADEMY_ENABLE_ONEAPI_LESSONS CMake option.

So the default build of the exercise code excludes the oneMath lessons, and turning them on is a deliberate opt-in rather than something you inherit. The lesson table for that section starts at 22 with OneMath GEMM.

oneMath is a library of optimised mathematical routines with a SYCL interface, and a GEMM exercise built on it is a different kind of lesson from the hand-written kernel exercises earlier in the course. Earlier lessons ask you to write the kernel; a library exercise asks you to call it and reason about the results. Both are worth teaching, but they are different exercises and they depend on different tooling.

The reason the caveat exists is not a defect in the materials but a property of the ecosystem. SYCL is a specification, and implementations differ in what they provide. The README is upfront that this is a portability limit rather than a hidden assumption.

That framing extends to the resources the README lists for anyone new to SYCL. There is a description of SYCL on the Khronos website SYCL page, a list of SYCL resources on the Khronos site, the SYCL 2020 reference guide in the Khronos registry, and the sycl.tech community website for news, blog posts, videos and projects. The same site carries a list of available SYCL implementations, which is the document to consult when deciding which implementation your students can actually run the exercises against.

There is also a playlist of video content, with the README's own warning attached: the slides and exercises may have changed since the videos were created, so they may not match completely.

Who writes and who supports the material

The contributor list tells you something useful about the intended audience, and it is broader than a single university lab.

The contributors are Codeplay Software Ltd., Heidelberg University, Intel, Xilinx, University of Bristol and Stream HPC. The supporting organisations are Abertay University, Universidad de Concepcion, TU Dresden, University of Edinburgh, Federal University of Sao Carlos, University of Glasgow, Heriot Watt University, Universitat Innsbruck, Universidad de Malaga, University of Salerno and the University of the West of Scotland.

That spread matters for a curriculum like this. Intel and Xilinx sit on opposite sides of the accelerator divide, and Codeplay and Stream HPC are the kind of organisations that build compilers rather than applications. A curriculum that has been touched by both a CPU vendor and a FPGA vendor is less likely to teach one hardware model as if it were the only one, and the presence of a compiler vendor among the contributors suggests the exercises were checked against real toolchains rather than written on paper.

The contributing process is deliberately light. Contributions are received by submitting a pull request with any changes, and the README asks that if you can, you follow the reveal.js instructions to generate a PDF file for any lecture slides you change. It also asks that you limit the scope of each pull request so they can be reviewed and merged in a timely manner.

The PDF request is a sensible thing to have asked for, since a lecturer on a slow connection or without a browser that handles the slides well will want a PDF. It also means the slide decks are effectively versioned artefacts, which matters for a course that cites them.

The repository has a CODE_OF_CONDUCT.md and a CONTRIBUTING.md, and the fact that the primary language is HTML with a package.json carrying reveal.js as the single dependency confirms that the slides are the centre of gravity and the C++ exercises are the companion.

Where SYCL Academy is the wrong choice

There are three limits, and the first is that it teaches one implementation path more than it teaches the specification.

The first is that the exercises are written against a concrete toolchain, and the oneMath section says so explicitly. A learner who has a SYCL implementation other than oneAPI will find that a subset of the exercises do not build, and the fix is the CMake option, not a code change. That is fine for a course where the instructor controls the environment and can say install this implementation, and it is a problem for self-directed learning where the reader picks their own tools and finds a broken build.

The second is that it is not a reference. The README itself points you to the SYCL 2020 reference guide in the Khronos registry for the specification, and to the sycl.tech site for everything current. SYCL Academy is a teaching sequence built on top of that, and the distinction matters for a learner who wants to know what the specification permits rather than how one course introduces it. A lesson can only show one idiomatic way to do a thing.

The third is the ageing of the content. The last push was on 2026-10-07, so the repository is being worked on, and the only tagged release is Dec-2024 from 2024-12-02. SYCL has moved through several revisions of the specification since that date, and the README's own warning that the video content may not match the current slides is the same problem in a different medium. Slides written for a specification revision teach the API of that revision.

The honest alternative depends on what you are doing. For learning the current specification, the SYCL 2020 reference guide and the sycl.tech resources are the primary sources, and they are updated with the specification rather than with a course sequence. For structured material that a cohort can work through together, the Khronos SYCL samples and the tutorials that ship with the reference guide give you worked examples per topic rather than a sequenced course. And for a vendor-neutral community view of what is current, the sycl.tech site is the place the ecosystem points.

What none of those replace is the thing this repository actually provides: a lesson sequence that has been tested by a room full of students, with the exercises, the starter files and the solutions already worked out. If you are teaching rather than self-studying, that is worth more than currency with the specification, and the PDF-generation request in the contributing guide is a reminder that the slides are meant to be handed to a room.

Editorial conclusion

Adopt SYCL Academy if you are teaching SYCL from scratch, whether in a course or a corporate onboarding track, since the slides and exercises are structured to be self-contained modules you can hand out as they are. Do not adopt it as a complete SYCL reference, since the README points at the SYCL 2020 reference guide for that. Before you teach from it, check the implementation you have against the oneMath lessons, which are only built by default for a DPC++ build, and note the last push was on 2026-10-07.

Frequently asked questions

Official sources

1. KhronosGroup/syclacademy on GitHub
2. License: CC-BY-SA-4.0
3. Project website
4. README
5. Releases