Setup Guide

This guide explains how to set up Artemis in your development environment or a demo production environment. For production setups, you would need to additionally consider topics discussed in the Administration Setup.

Running Artemis consists of two main steps:

1. Set up the development environment (see Development Environment Setup).
2. Set up Artemis (see Set up Artemis), which includes setting up optional but recommended features such as programming exercises. The installation guide provides two options for programming exercises, including version control and build system setup.

Artemis is based on JHipster, combining:

• Spring Boot (Java 25) for the application server.
• Angular 22 (TypeScript) for the web application that serves the user interface.

To get an overview of the technology stack, visit the JHipster Technology Stack and refer to other tutorials on the JHipster homepage.

Development Environment Setup

Before installing Artemis, install and configure the following dependencies:

Required Dependencies

1. Java JDK 25 Download and install Java (e.g., from Oracle JDK)

2. Database Server Artemis uses Hibernate for database interactions and Liquibase for schema migrations. PostgreSQL is the default and recommended database server. MySQL is still supported but deprecated and removed in Artemis 11 (see Planned removals in Artemis 11). See Database Setup for details.

3. Node.js (LTS ≥ 24.21.0 < 25) Download from Node.js. Required for compiling and running the Angular client.

4. pnpm (≥ 12.15.0) — the package manager Artemis uses for the Angular client

   The official pnpm website is pnpm.io; the CLI reference for pnpm install is at pnpm.io/cli/install and the installation guide at pnpm.io/installation. Artemis uses pnpm instead of npm. We do not use npm / npx anywhere; please don't run npm install in this repo — it will create a package-lock.json that conflicts with the committed pnpm-lock.yaml. The exact pnpm version is pinned in package.json via the packageManager field, so every developer and every CI job uses the same version.

   You don't need to follow the official pnpm install steps manually — Node.js 24 ships with Corepack, a small shim that downloads and runs the pinned package manager on demand. This is also the installation method recommended by the pnpm team. Activate it once per machine:

   corepack enable

   After that, any pnpm command run inside the Artemis repository automatically uses the pinned version. Verify the setup with:

   pnpm --version          # should print 12.15.0 (matches packageManager in package.json)
   which pnpm              # should point at the Corepack shim, e.g. ~/.nvm/.../bin/pnpm

   First-time install of dependencies (after cloning the repo):

   pnpm install            # installs everything declared in package.json + pnpm-lock.yaml

   Troubleshooting corepack enable:

   • Permission denied / EACCES on macOS or Linux: Corepack writes shim symlinks next to the Node.js binary. If Node.js was installed system-wide (e.g. via apt/brew install node), run sudo corepack enable once. With nvm, fnm, or Volta, no sudo is needed.
   • corepack: command not found: Your Node.js install is too old or was built without Corepack. Reinstall Node.js 24+ from nodejs.org; Corepack is included by default.
   • pnpm: command not found after corepack enable: Restart your shell so the new shim is picked up on PATH.
   • Behind a corporate proxy: Corepack fetches the pinned pnpm tarball from npmjs.org on first use. Set HTTPS_PROXY / HTTP_PROXY env vars if your network requires it.

   We migrated from npm to pnpm to get deterministic, content-addressable installs (faster cold installs locally and in CI, byte-identical node_modules across machines, stricter override semantics, and patch application via pnpm.patchedDependencies instead of a postinstall patch-package step).

5. Graphviz (Optional, but Recommended for Production Setups) Install from Graphviz to enable graph generation in exercise descriptions.

⚠️

Warning:

Missing Graphviz in production may cause rendering errors for exercise descriptions.

IDE Setup

We recommend using IntelliJ IDEA Ultimate for development. Refer to JHipster's guide on configuring an IDE: JHipster IDE Setup.

ℹ️

Information:

The Community Edition of IntelliJ IDEA lacks Spring Boot support. See the comparison matrix for details.

Set up Artemis

Once the development environment is set up, the next step is to configure the Artemis server. This includes optional features such as programming exercises, which require a version control and build system.

Start by following the Database Setup guide, then proceed with Server Setup and Client Setup.

Database Setup

Artemis supports MySQL and PostgreSQL databases. The required Artemis schema is created or updated automatically when the server application starts.

⚠️

Warning:

MySQL support is deprecated and removed in Artemis 11 (March 2027), which leaves PostgreSQL as the only database. The dev profile still defaults to a local MySQL datasource for now. For new setups, use PostgreSQL. See Planned removals in Artemis 11.

MySQL Setup

You can set up a MySQL database for Artemis using one of the following methods:

Using Docker (Recommended)

The easiest way to set up a MySQL database for development is by using Docker. Run the following command to start a MySQL database using the provided Docker Compose file:

docker compose --env-file .env -f deployment/docker/mysql.yml up

This method simplifies setup and management, making it ideal for development environments.

Using a Local MySQL Installation

If you prefer to install MySQL locally, download and install the MySQL Community Server (9.2.x) from the official MySQL website.

When running a local MySQL server, ensure the following settings for character encoding and collation:

• character-set: utf8mb4
• collation: utf8mb4_unicode_ci

These settings can be configured using a my.cnf file located in /etc:

[client]
default-character-set = utf8mb4
[mysql]
default-character-set = utf8mb4
[mysqld]
character-set-client-handshake = TRUE
init-connect='SET NAMES utf8mb4'
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci

Ensure that MySQL loads this configuration file when starting the server. For more details, refer to the official MySQL documentation: MySQL Option Files.

The server configuration does not cover the connection. MySQL Connector/J connects with utf8mb4_0900_ai_ci unless the JDBC URL sets connectionCollation=utf8mb4_unicode_ci, and some searches, such as those for course or conversation members, then fail with Illegal mix of collations. The datasource URLs of the dev and docker profiles set it; keep it when you override spring.datasource.url. See MySQL Character Set and Collation.

Users for MySQL

For the development environment, the default MySQL user is root with an empty password. (In case you want to use a different password, make sure to change the value in application-local.yml (spring > datasource > password) and in liquibase.gradle (within the 'liquibaseCommand' as argument password)).

Set empty root password for MySQL 9 and later

If you have problems connecting to a MySQL 9 or later database using an empty root password, you can try the following command to reset the root password to an empty password:

mysql -u root --execute "ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY ''";

⚠️

Warning:

Empty root passwords should only be used in a development environment. The root password for a production environment must never be empty.

PostgreSQL Setup

No special PostgreSQL settings are required. You can either use your package manager's version, or set it up using a container. An example Docker Compose setup based on the official container image is provided in deployment/docker/postgres.yml.

When setting up the Artemis server, the following values need to be added/updated in the server configuration (see setup steps below) to connect to PostgreSQL instead of MySQL:

spring:
    datasource:
        url: jdbc:postgresql://localhost:5432/Artemis?ssl=false
        username: Artemis
    jpa:
        database: POSTGRESQL

ℹ️

Information:

This example assumes that you use the mentioned Docker Compose file on your localhost, leading to a database called Artemis that runs on port 5432 and where no password is necessary. You might have to update spring.datasource.url if you use another configuration and set the password in spring.datasource.password.

Server Setup

ℹ️

Information:

First-time deployment checklist:

Before starting the Artemis server for the first time:

1. Database: Ensure a database is running. See Database Setup for instructions.
2. Configuration: Create application-local.yml in src/main/resources/config (see Configuration Setup below).
3. Deployment: We recommend deploying Artemis Server (Dev, BuildAgent+LocalCI) for local development.

To start the Artemis application server from the development environment, first import the project into IntelliJ IDEA. Make sure to install the Spring Boot plugins for IntelliJ IDEA, this will make it easier to run the server.

As an alternative, you may consider running the entire Artemis application using the Helios application. See Setup with Helios for more details.

Before starting the application, update the required configuration settings.

Configuration Setup

Configuration settings are stored in application-artemis.yml (located in src/main/resources/config). However, do not modify this file directly, as it may lead to accidental commits of sensitive information.

Instead, follow these best practices:

1. Create a custom configuration file

   • In src/main/resources/config, create a new file named application-local.yml.
   • This file is used to override settings in application.yml for local development environments. It is configured to be ignored by Git to ensure that local configurations are not committed.

2. Customize configuration settings

   • If you want to change application properties, you should do that in application-local.yml.
   • If needed, you can modify values such as database credentials, authentication and application settings.

3. Set the installation metadata (optional)

   • The About page shows who operates the installation. A development server starts without these values; only the production profile, as in the Artemis Server (Prod, Core, LocalCI) run configuration, requires them unless info.testServer is true. To set them, add them to application-local.yml, replacing the examples with your own:

   info:
       operatorName: Research group of Applied Education Technologies
       operatorAdminName: Jane Doe
       universityName: Technical University of Munich

   • Empty values and template values such as Admin, Your University or <name> are rejected, and the error names the properties to fix. See Telemetry for details.

4. Activate the correct profile

   • When running Artemis, ensure the local profile is selected in the run configurations.
   • For additional custom configurations, create application-<name>.yml and activate the <name> profile.

Common Configuration Options

For development purposes, these settings are preconfigured, and no action is necessary in this step. You only need to modify them if your specific work or production environments require changes.

artemis:
    repo-clone-path: ./repos/
    legal-path: ./legal/
    repo-download-clone-path: ./repos-download/
    bcrypt-salt-rounds: 11   # The number of salt rounds for bcrypt password hashing.
                             # Lower values improve speed but reduce security.
                             # Use the bcrypt benchmark tool to determine an optimal value: https://github.com/ls1intum/bcrypt-Benchmark

    user-management:
        use-external: true # enables ldap authentication
        passkey:
          enabled: true
        password-reset:
            links:
                en: '<link>'
                de: '<link>'
        ldap:
            url: <url>
            user-dn: <user-dn>
            password: <password>
            base: <base>
            allowed-username-pattern: '^([a-z]{2}\d{2}[a-z]{3})$'    # example for a TUM identifier, e.g. ab12cde

    git:
        name: Artemis
        email: artemis@in.tum.de

    # Required module feature toggles
    atlas:
      enabled: true
      atlasllm:
        enabled: false   # Atlas chat agent and competency orchestration; needs a chat model under spring.ai (see artemis-intelligence.mdx). Competencies and learning paths work without it.
    exam:
      enabled: true
    fileupload:
      enabled: true
    lecture:
      enabled: true
    lti:
      enabled: true
    modeling:
      enabled: true
    plagiarism:
      enabled: true
    text:
      enabled: true
    tutorialgroup:
      enabled: true
    sharing:
      enabled: true
    hyperion:
      enabled: true
    weaviate:
      enabled: false   # global search; enable together with a running Weaviate instance (see weaviate-setup.mdx)

    athena:
        # If you want to use Athena, refer to the dedicated configuration section. Under Administration Guide, Setup of Extension Services.

ℹ️

Information:

If you use a password for authentication, update it in gradle/liquibase.gradle.

Version Control & Continuous Integration Setup

If you are setting up programming exercises, additional configuration is required for the version control and build system. Refer to one of the following guides based on your preferred setup:

• Integrated Code Lifecycle Setup (Recommended)
• LocalVC + Jenkins Setup (deprecated, removed in Artemis 11, see Planned removals in Artemis 11)

Run the server via a run configuration in IntelliJ

The project comes with some pre-configured run / debug configurations that are stored in the .idea directory. When you import the project into IntelliJ the run configurations will also be imported.

The recommended way is to run the server and the client separately. This provides fast rebuilds of the server and hot module replacement in the client.

• Artemis (Client): Will execute pnpm install and pnpm start. The client will be available at http://localhost:9000/ with hot module replacement enabled (also see Client Setup).
• Artemis Server (Dev, BuildAgent+LocalCI): The server will be started separated from the client with the profiles dev,artemis,localci,localvc,scheduling,buildagent,core,local. Enable LDAP via artemis.user-management.ldap.enabled=true in your application-local.yml.
• Artemis Server (Dev, Core, Jenkins): (deprecated, removed in Artemis 11) The server will be started separated from the client with the profiles dev,jenkins,localvc,artemis,scheduling,core,local.
• Artemis Server (Dev, LocalCI+BuildAgent, Athena): The server will be started separated from the client with the profiles dev,localci,localvc,artemis,scheduling,buildagent,core,local. Enable Athena via artemis.athena.enabled=true in your application-local.yml.
• Artemis Server (Dev, LocalCI+BuildAgent, Iris): The server will be started separated from the client with the profiles dev,localci,localvc,artemis,scheduling,buildagent,core,local and the VM option -Dartemis.iris.enabled=true.
• Artemis BuildAgent (Prod): The server will be started separated from the client with the profiles buildagent,local. This configuration is used to run the build agent for the local CI. This configuration is rarely needed for development.
• Artemis Server (Prod, Core, LocalCI): The server will be started separated from the client with the profiles prod,core,localvc,localci,scheduling,local. Enable LDAP via artemis.user-management.ldap.enabled=true in your environment config. This configuration is used for production-like testing.

Run the server via Docker

ℹ️

Information:

This method provides a fast way to start Artemis for demonstration purposes. It is not recommended for development, as it does not support code modifications or debugging.

Artemis provides a Docker image named ghcr.io/ls1intum/artemis:<TAG/VERSION>:

• The current develop branch is available under the tag develop.
• The latest stable release can be retrieved using the tag latest.
• Specific releases, such as 7.10.8, can be accessed with ghcr.io/ls1intum/artemis:7.10.8.
• Branches tied to a pull request can be obtained using PR-<PR NUMBER>.

Dockerfile

You can find the latest Artemis Dockerfile at deployment/docker/artemis/Dockerfile.

• The Dockerfile has multiple stages: A builder stage, building the .war file, an optional external_builder stage to import a pre-built .war file, a war_file stage to choose between the builder stages via build argument and a runtime stage with minimal dependencies just for running artemis.

• The Dockerfile defines three Docker volumes (at the specified paths inside the container):

  • /opt/artemis/config:

    This can be used to store additional configurations of Artemis in YAML files. The usage is optional, and we recommend using the environment files for overriding your custom configurations instead of using src/main/resources/config/application-local.yml as such an additional configuration file. The other configurations like src/main/resources/config/application.yml, ... are built into the .war file and therefore are not needed in this directory.

    ℹ️

    Information:

    Instead of mounting this config directory, you can also use environment variables for the configuration as defined by the Spring relaxed binding. You can either place those environment variables directly in the environment section, or create a .env-file. When starting an Artemis container directly with the Docker-CLI, an .env-file can also be given via the --env-file option. To ease the transition of an existing set of YAML configuration files into the environment variable style, a helper script can be used.

  • /opt/artemis/data:

    This directory should be used for any data (e.g., local clone of repositories). This is preconfigured in the docker Java Spring profile (which sets the following values: artemis.repo-clone-path, artemis.repo-download-clone-path, artemis.course-archives-path, artemis.submission-export-path artemis.legal-path, and artemis.file-upload-path).

  • /opt/artemis/public/content:

    This directory will be used for branding. You can specify a favicon here.

• The Dockerfile assumes that the mounted volumes are located on a file system with the following locale settings (see #4439 for more details):

  • LC_ALL en_US.UTF-8
  • LANG en_US.UTF-8
  • LANGUAGE en_US.UTF-8

⚠️

Warning:

ARM64 Image builds might run out of memory if not provided with enough memory and/or swap space. On an Apple M1 we had to set the Docker Desktop memory limit to 12GB or more.

Required Configuration

ℹ️

Information:

The Docker image requires several module properties to be explicitly configured. Without them, the server will fail to start with an error such as: Property artemis.atlas.enabled not found in Artemis configuration. Make sure to add it to your application.yml-file.

To provide the required configuration, one option is to create an application-local.yml and mount it into /opt/artemis/config/. Use the properties from Common Configuration Options as a base, and add a spring.datasource block:

# application-local.yml
# ... all other properties from Common Configuration Options
info:
    # Optional: the installation metadata from step 3 of the configuration setup
    operatorName: <operator>
    operatorAdminName: <administrator>
    universityName: <university>
spring:
    datasource:
        # If your database is running in another Docker container locally on your machine, replace `<db-host>` with `host.docker.internal` (macOS/Windows) or the host's IP address (Linux).
        url: "jdbc:mysql://<db-host>:3306/Artemis?createDatabaseIfNotExist=true&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf8&connectionCollation=utf8mb4_unicode_ci&useSSL=false&useLegacyDatetimeCode=false&serverTimezone=UTC"
        # Depending on your database setup, the following may be required:
        username: root
        password: ""

Then run the container using the following command and replace <TAG/VERSION> as described above:

docker run \
  -v "$PWD/application-local.yml:/opt/artemis/config/application-local.yml:ro" \
  -e SPRING_CONFIG_ADDITIONAL_LOCATION=file:/opt/artemis/config/ \
  -e SPRING_PROFILES_ACTIVE=dev,artemis,localci,localvc,scheduling,buildagent,core,local \
  -e ARTEMIS_USER_MANAGEMENT_LDAP_ENABLED=true \
  -e ARTEMIS_APOLLON_ENABLED=true \
  -p 8080:8080 \
  ghcr.io/ls1intum/artemis:<TAG/VERSION>

Alternatively, you can pass properties directly as Docker environment variables using Spring's relaxed binding (e.g. artemis.atlas.enabled → ARTEMIS_ATLAS_ENABLED). You can adapt the following to your needs:

docker run \
  -e ARTEMIS_ATLAS_ENABLED=true \
  -e INFO_OPERATORNAME="<operator>" \
  -e INFO_OPERATORADMINNAME="<administrator>" \
  -e INFO_UNIVERSITYNAME="<university>" \
  -e SPRING_DATASOURCE_URL="jdbc:mysql://<db-host>:3306/Artemis?..." \
  ...
  -p 8080:8080 \
  ghcr.io/ls1intum/artemis:<TAG/VERSION>

Debugging with Docker

The Docker containers have the possibility to enable Java Remote Debugging via Java environment variables. Java Remote Debugging lets you use your preferred debugger connected to port 5005. For IntelliJ, you can use the Remote Java Debugging for Docker profile shipped in the git repository.

With the following Java environment variable, you can configure the Remote Java Debugging inside a container:

_JAVA_OPTIONS="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005"

This is already pre-set in the Docker Compose Artemis-Dev-MySQL Setup. For issues at the startup, you might have to suspend the java command until a Debugger is connected. This is possible by setting suspend=y.

Run the server with Spring Boot and Spring profiles

The Artemis server should startup by running the main class de.tum.cit.aet.artemis.ArtemisApp using Spring Boot.

ℹ️

Information:

Artemis uses Spring profiles to segregate parts of the application configuration and make it only available in certain environments. For development purposes, the following program arguments can be used to enable the dev profile and the profiles for LocalCI and LocalVC:

--spring.profiles.active=dev,artemis,localci,localvc,scheduling,buildagent,core,local

If you use IntelliJ (Community or Ultimate) you can set the active profiles by:

• Choosing Run | Edit Configurations...
• Going to the Configuration tab
• Expanding the Environment section to reveal VM Options and setting them to -Dspring.profiles.active=dev,artemis,localci,localvc,scheduling,buildagent,core,local

Set Spring profiles with IntelliJ Ultimate

If you use IntelliJ Ultimate, add the following entry to the Active Profiles field (within Spring Boot) in the server run configuration:

dev,artemis,localci,localvc,scheduling,buildagent,core,local

Run the server with the command line (Gradle wrapper)

If you want to run the application via the command line instead, make sure to pass the active profiles to the gradlew command like this:

./gradlew bootRun --args='--spring.profiles.active=dev,artemis,localci,localvc,scheduling,buildagent,core,local'

Demo data (Optional)

To start Artemis with a demo course, add the demo profile to the active profiles. Seeding only runs on a node that is also active with core and scheduling, so in a multi-node setup exactly one node seeds:

--spring.profiles.active=dev,localci,localvc,artemis,scheduling,buildagent,core,local,demo

On startup, Artemis creates whatever is missing of the demo course Introduction to Software Engineering (short name demo) and leaves everything that already exists untouched. All demo users have the password demo1234:

User	Role in the demo course
demo_student	Student. Use this user to explore the student view.
demo_student_1 to demo_student_10	Students. Their submissions fill the statistics, the scores and the assessment queue.
demo_tutor	Tutor. Assessed the graded essay and leads the tutorial groups.
demo_editor	Editor.
demo_instructor	Instructor. Owns the demo content.

The demo course contains:

• Exercises: one open exercise of every type to try out: Essay: Monolith or Microservices?, Class Diagram: Library Management System, Poster: Comparing Sorting Algorithms, Quiz: Java Collections and Complexity and the programming exercise Sorting Algorithms in Java. In addition, the essay Essay: The Value of Code Reviews has published results with feedback and an open complaint of a classmate, the submissions to Class Diagram: Online Shop wait in the assessment queue of demo_tutor, and Quiz: Sorting and Searching has ended, has results and statistics, and is open for practice.
• Exam: the test exam Practice Exam: Software Engineering Fundamentals with an essay, a class diagram and a quiz, which every student can start as often as they like.
• Lectures: the past lectures Software Architecture, Algorithms and Complexity and Object-Oriented Modeling, each with a text unit, a link to further reading and its exercises, and slides for Software Architecture.
• Competencies: the prerequisite Program in Java and four competencies, linked to the exercises and lecture units of their topics and related to each other. Learning paths are enabled, and demo_student has completed some lecture units and made progress.
• Tutorial groups: Monday Tutorial on campus and Thursday Online, each with weekly sessions over the whole course, its students and a channel, and the free period Reading Week, which cancels their sessions for a week.
• Communication: a welcome announcement, threads with replies and, if the plagiarism module is enabled, reactions in the course channels, direct messages between demo_student and demo_tutor, and FAQs.
• Grading: a grading scale from 5.0 to 1.0, with 4.0 as the first passing grade.

The programming exercise is only created with a version control and a continuous integration system, for example the localvc and localci profiles, and its builds need a build agent. All other content only needs the modules it belongs to, so a disabled module simply leaves its part out.

Seeding goes through the same services as the user interface, acting as the demo user who would perform each action. It therefore also sends the notifications those actions cause, including emails to the demo users' addresses <login>@artemis.local.

The dates of the demo content are relative to the start that creates it and are never moved. A graded essay's complaint period, for example, ends a week after it was created, while the open exercises and the test exam stay open for a year.

Restarting never duplicates the demo data. Deleted demo content is recreated on the next start as a whole, a deleted exercise for example with all its submissions and results. Lecture units and the links and relations of competencies are also recreated one by one, but other parts of content that still exists are not, such as a single deleted submission.

⚠️

Warning:

The demo credentials are publicly known. Only use the demo profile on demo and manual testing instances, never on a production instance.

Hyperion (Optional)

Hyperion provides AI-assisted exercise creation features via Spring AI. No external Edutelligence service is required, only a LLM provider such as OpenAI or Azure OpenAI.

ℹ️

Information:

For local development with LM Studio (no cloud API keys required), see the Spring AI Development Guide.

For production setup, see Hyperion Service in the Administration Guide for instructions on enabling the module in production and configuring LLM credentials.

Client Setup

You need Node.js on your local machine, plus pnpm activated via Corepack (corepack enable). The pnpm version is pinned in package.json via the packageManager field. If you haven't activated pnpm yet, see step 4 of Required Dependencies above for the full first-time setup and troubleshooting tips.

Using IntelliJ

If you are using IntelliJ you can use the pre-configured Artemis (Client) run configuration that will be delivered with this repository:

• Choose Run | Edit Configurations...
• Select the Artemis (Client) configuration from the npm section (IntelliJ groups package.json scripts under "npm" even though we run pnpm)
• Now you can run the configuration in the upper right corner of IntelliJ

Using the command line

If this is your first time setting up the client, activate the pinned pnpm version once:

corepack enable

You should then be able to run the following command to install development tools and dependencies. You will only need to run this command when dependencies change in package.json.

pnpm install

In CI (and whenever you want the install to fail rather than silently update the lockfile), use:

pnpm install --frozen-lockfile

To start the client application in the browser, use the following command:

pnpm start

This compiles TypeScript code to JavaScript code, starts the live reloading feature (i.e. whenever you change a TypeScript file and save, the client is automatically reloaded with the new code) and will start the client application in your browser on http://localhost:9000. If you have configured application-artemis.yml correctly, then you should be able to login with your TUM Online account.

ℹ️

Information:

In case you encounter any problems regarding JavaScript heap memory leaks when executing pnpm start or any other scripts from package.json, you can adjust the memory limit parameter (node-options=--max-old-space-size=6144) which is set by default in the project-wide .npmrc file. pnpm honours node-options from .npmrc for Node settings; pnpm's own install/resolution configuration lives in pnpm-workspace.yaml (e.g. autoInstallPeers, allowBuilds, patchedDependencies). If you still face the issue, you can try to set a lower/higher value than 6144 MB. Recommended values are 3072 (3GB), 4096 (4GB), 5120 (5GB), 6144 (6GB), 7168 (7GB), and 8192 (8GB). You can override the project-wide .npmrc file by using a per-user ~/.npmrc. Make sure to not commit changes in the project-wide .npmrc unless the GitHub build also needs these settings.

For more information, review Working with Angular. For further instructions on how to develop with JHipster, have a look at Using JHipster in development.

Common Setup Problems

General Setup Problems

• Restarting IntelliJ with invalidated caches (File > Invalidate Caches...) might resolve the current issue.
• When facing issues with deep dependencies and changes were made to the package.json file, deleting node_modules and running pnpm install again resolves most issues. To bypass the lockfile (e.g. after manually editing dependency ranges), use pnpm install --no-frozen-lockfile.
• When encountering a compilation error due to invalid source release make sure that you have set the Java version properly at 3 places:
  • File > Project Structure > Project Settings > Project > Project SDK
  • File > Project Structure > Project Settings > Project > Project Language Level
  • File > Settings > Build, Execution, Deployment > Build Tools > Gradle > Gradle JVM

Database

• One typical problem in the development setup is that an exception occurs during the database initialization. Artemis uses Liquibase to automatically upgrade the database scheme after the data model has changed. This ensures that the changes can also be applied to the production server. In case you encounter errors with Liquibase checksum values:
  • Run the following command in your terminal / command line:
    ./gradlew liquibaseClearChecksums
  • You can manually adjust the checksum for a breaking changelog:
    UPDATE `DATABASECHANGELOG` SET `MD5SUM` = NULL WHERE `ID` = '<changelogId>'

Client

• If you are using a machine with limited RAM (e.g. ~8 GB RAM) you might have issues starting the Artemis Client. You can resolve this by following the description in Using the command line.
• pnpm: command not found after cloning the repo: run corepack enable once (see step 4 of Required Dependencies). If corepack itself is missing, your Node.js install is too old; reinstall Node.js 24+ from nodejs.org.
• Accidentally ran npm install and got a package-lock.json: delete package-lock.json and node_modules, then run pnpm install. The repository's .gitignore blocks package-lock.json from being committed, but a stray copy still confuses tooling.
• pnpm install complains the lockfile is out of date: the lockfile is authoritative; running pnpm install locally without --frozen-lockfile updates it. If your edit was intentional (e.g. you bumped a dependency in package.json), commit the updated pnpm-lock.yaml. If not, run git checkout pnpm-lock.yaml and rerun pnpm install --frozen-lockfile.

Production Setup and Extension Services

Production Setup

A production setup of these core services might need further adaptation to ensure security. For details on securing your production environment, see the Administration Setup.

Extension Services

Artemis allows extension with several additional services, such as:

• Mobile notifications via Hermes
• Automatic feedback generation using large language models (e.g., Iris/Athena)
• And more...

The setup for these additional services is described as part of the Extension Service Setup.

Setup with Helios

Helios is an application that provides a well-designed UI for deploying various services the AET is building using GitHub Actions. You can use Helios to deploy an Artemis test server without needing to set up the server and client manually.

This is particularly useful for:

• Quick deployment of test environments
• Deploying Artemis without local development setup
• Testing pull request branches in isolated environments

For detailed instructions on setting up Artemis with Helios, refer to the official Helios User Guide.

ℹ️

Information:

If the above link is unavailable, go to the Helios documentation homepage and navigate to User Guide → Helios User Guide.

Additional Setup Guides

For more advanced setup scenarios and development tools, see the following guides:

• Jenkins and LocalVC Setup - Deprecated CI/CD setup using Jenkins with LocalVC, removed in Artemis 11
• OpenAPI and API-driven Development - Working with OpenAPI specifications
• Docker Compose Setup - Alternative Docker Compose-based deployment
• Docker Debugging - Debugging Artemis in Docker containers
• Local Database Tests - Running database tests locally