Artemis turns a university course into a self-hosted platform for interactive exercises

A platform for a course team, not a tool for a single learner

Artemis is described as an open-source platform for interactive learning with individual feedback. The framing matters: the unit of deployment is an institution, not a student. Universities deploy and operate Artemis on their own infrastructure, which is the entire point for courses where code, submissions and grades are sensitive.

What the platform aims to deliver is scalable interactive learning with authentic assessment, adaptive learning and responsible AI support. The distinctive mechanism is that feedback is individual rather than broadcast. Programming submissions are built, tested and analysed automatically. Quizzes are evaluated on submission. Text and modeling exercises combine a manual assessment path with feedback suggestions, so a human still reads the work where reading matters.

The exercise types are first-class objects rather than add-ons to a document system. Programming, modeling, text, quiz and file-upload exercises each have their own object model, and the same exercise types are reused for coursework and for examinations, which means an instructor can move an exercise into exam mode without rebuilding it.

For a reader deciding whether to deploy this, the honest summary is that Artemis is a large platform with a large surface area. It bundles version control, continuous integration, static code analysis, assessment, exams, learning analytics and optional AI helpers in one product. That consolidation is the reason a university would pick it, and also the reason a small team would hesitate.

Version control, CI and static analysis inside the exercise itself

The integrated code lifecycle is the part that most changes how a programming course is run. According to the documentation, Artemis includes built-in version control and continuous integration with scalable build agents, so no external VCS or CI system is required. In other words, the platform hosts the git repositories for exercise code and runs the test suite itself.

The try-it instructions describe that stack concretely: the local setup includes the integrated code lifecycle, so Artemis hosts the git repositories and a build agent runs the tests. The Compose file named for the local variant carries `vc-local-ci` in its filename, which lines up with version control and continuous integration running inside the container set rather than being reached over the network.

The build agent is a separate service with its own scaling story, since a course of several hundred students submitting at the same deadline is a queueing problem rather than a code problem. The documentation refers to scalable build agents, which is the term to look for when sizing a deployment.

Programming exercises also carry test-case based feedback, static code analysis, submission policies and templates for 20 languages. The write up adds that any language that runs in a build container can be added, which is the escape hatch for courses in a language the template set does not cover. Static analysis matters more than it used to, because it gives students feedback on their submission before a human grader looks at it, which is where the per-student scaling actually comes from.

Iris, Athena and Hyperion stay behind a configuration gate

The AI story is deliberately fenced. Three named integrations are listed: Iris, Athena and Hyperion. They are described as optional, configuration-gated integrations, and the write up is explicit that instructors and tutors stay responsible for assessment decisions. That framing is the distinguishing point against tools that present automated grading as the outcome.

Nothing in the write up describes what each of the three does individually. What can be said from the documentation is that they are separate switches rather than one global toggle, so a course can enable one and leave the others off, and that they are integrations in the sense that they connect to something outside the platform. Which services they call, and what data leaves the deployment, is not documented in the write up, and that gap is worth closing before enabling any of them in a course with privacy obligations.

Apollon appears in the frontend dependency list as `@tumaet/apollon`, which is the modelling component used by modeling exercises. The exercise type is listed in the capabilities table with the same assessment model as the others, so a UML-style diagram can be assessed on the same footing as code or a quiz.

Exam mode with variants per student, test runs and plagiarism checks

Online examination is where a platform like this either earns its operational cost or does not. The write up describes coursework and examinations using the same exercise types, with exercise variants per student, test runs, plagiarism checks and structured student reviews.

Variants per student means every student receives a different version of the same exercise, which removes the value of sharing answers with a neighbour. Test runs let a student execute the exercise in the exam environment before submission, so a configuration problem does not cost them the attempt. Structured student reviews are a peer feedback mechanism rather than a free-text comment box.

Plagiarism checks appear alongside these, which is significant for short programming exams, where the number of distinct correct solutions is often small enough that similarity detection is practical.

The quiz exercise type supports multiple choice, drag and drop and short answer questions in live, practice and exam mode. Practice mode is the mode to point students at before an exam, and the exercises table also lists a practice mode for the exercise types in general, along with automatic and manual assessment, team exercises and multiple submissions.

The honest limit here is that exam mode is a mode, not a guarantee. The write up does not describe browser lockdown, network isolation during an exam, or how the platform handles a student whose machine dies mid-assessment. Those are questions for the instructor guide and the exam documentation, not for a feature list.

One Docker Compose command brings up an instance with working exercises

The quickest way to see the system is the local try-it path, which the documentation presents as a complete Artemis with working programming exercises, from the repository root, with no configuration, using published images for `amd64` and `arm64`.

On a Linux host with a native Docker daemon, the group id for the docker group has to be exported first, because the build agent needs the host docker group to reach the Docker socket and Compose resolves it when it creates the container:

export ARTEMIS_DOCKER_GROUP_ID=$(getent group docker | cut -d: -f3)
docker compose --env-file .env -f deployment/docker/artemis-dev-local-vc-local-ci-postgres.yml pull
docker compose --env-file .env -f deployment/docker/artemis-dev-local-vc-local-ci-postgres.yml up

The pull and the up are separate commands, so the images are fetched before the stack starts. The Compose file name ends in `postgres`, which identifies the database used by this local variant. On Docker Desktop for macOS and Windows no docker group exists, so the export line is harmless and can be skipped.

When the stack is up, the instance listens on port 8080 and the documented credentials are `artemis_admin` / `artemis_admin`. The instructions also note that the local setup leaves some things out, and point to the Try Artemis documentation page for the full list and for how to get a hosted trial instead. The TUM instance is at https://artemis.tum.de, which is the quickest way to see the platform with real course data.

Competencies and learning paths drive the adaptive learning side

Adaptive learning is described through competencies, learning paths and learning analytics, which let courses adapt to individual progress. The distinction from a generic learning management system is granularity: a competency is a named skill that exercises can be tagged against, and a learning path is the route through the material.

In practice this changes course authoring. An instructor can see which competencies a cohort has covered and where progress stalled, and can steer the next session toward the weak area. That is a reporting and authoring benefit first, and an automatic personalisation benefit second, and the write up does not claim the latter.

Learning analytics is a separate entry in the same list, which suggests the data is surfaced to staff rather than only used internally. What that analytics contains, how long it is retained, and whether it is exposed to students is not described in the write up. For a course under a data protection regime, that is a question to answer in the documentation before enabling it, not after the first term.

The other half of the adaptive claim is the assessment mix itself. Text and modeling exercises combine manual assessment with feedback suggestions, which means a large cohort can get per-subject feedback without every submission being read from scratch. How the suggestions are produced is not documented here.

MIT licence, a two week release cadence and a Java backend with an Angular frontend

Artemis is MIT-licensed, developed in public and self-hosted. The licence permits use, modification and redistribution, including in commercial settings, which matters for institutions that run a modified fork internally and for companies that offer it as a hosted product. This is a statement about the licence terms, not legal advice.

The release cadence is documented as a minor release every two weeks, and the recent tags fit that pattern: 10.2 on 2026-10-08, 10.3 on 2026-10-14 and 10.3.1 on 2026-10-16. The last push to the repository was on 2026-10-20. A two week minor cadence is fast enough that a deployment plan has to include a scheduled upgrade, and the documentation has a dedicated release and support policy page for that.

Technically, the backend is Java built with Gradle, with `build.gradle`, `settings.gradle` and `gradlew` at the repository root, and the frontend is Angular with a TypeScript configuration, `angular.json`, `tsconfig.json` and a pnpm workspace using `[email protected]`. The workspace layout with a `packages/` directory and a workspace dependency on `@tumaet/ui-angular` shows a shared component library rather than a single app. The repository also carries `AGENTS.md`, `CLAUDE.md` and a `skills/` directory, which points to an active effort to make the codebase navigable for automated tooling.

A deployment of this platform is therefore not a small install. It is a Java service, an Angular frontend, a PostgreSQL database, a git server and a build agent, and the documentation treats it as an operational commitment that institutions take on themselves.

Editorial conclusion

Artemis suits a university course team with an operations budget, a Java and TypeScript engineering appetite and a policy preference for keeping student code on infrastructure it controls. It does not suit a small institute without anyone willing to run a server, a build agent and a database, and it is the wrong tool for a single self-paced course. Before adopting, read the Try Artemis page to see exactly what the local Docker setup leaves out, confirm that a build agent and a PostgreSQL instance are available to your deployment, and check the release and support policy page to see how often your team is expected to absorb a minor release.

Frequently asked questions

Official sources

1. License: MIT
2. ls1intum/Artemis on GitHub
3. Project website
4. README
5. Releases