diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 6622921..f2c1963 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -4,11 +4,8 @@
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
-        <option name="delegatedBuild" value="true" />
-        <option name="testRunner" value="GRADLE" />
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="11" />
+        <option name="gradleJvm" value="17" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
diff --git a/gradle.properties b/gradle.properties
index b35e401..e58ce24 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -4,24 +4,24 @@
 pluginGroup = com.github.ragurney.spotless
 pluginName = Spotless Gradle
 # SemVer format -> https://semver.org
-pluginVersion = 2.0.0
+pluginVersion = 2.1.0
 
 # See https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 # for insight into build numbers and IntelliJ Platform versions.
-pluginSinceBuild = 211
+pluginSinceBuild = 241
 # Removed to ease compatibility of future IntelliJ releases and this plugin. See GH issue #43
 #pluginUntilBuild = null
 
 # IntelliJ Platform Properties -> https://github.com/JetBrains/gradle-intellij-plugin#intellij-platform-properties
 platformType = IC
-platformVersion = 2021.1
+platformVersion = 2024.1.2
 
 # Plugin Dependencies -> https://plugins.jetbrains.com/docs/intellij/plugin-dependencies.html
 # Example: platformPlugins = com.intellij.java, com.jetbrains.php:203.4449.22
 platformPlugins = com.intellij.gradle
 
 # Java language level used to compile sources and to generate the files for - Java 11 is required since 2020.3
-javaVersion = 11
+javaVersion = 17
 
 # Gradle Releases -> https://github.com/gradle/gradle/releases
 gradleVersion = 7.3
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 6d0b2cb..7e19b53 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1 +1 @@
-rootProject.name = "spotless"
+rootProject.name = "spotless-intellij-gradle"
diff --git a/src/main/java/com/github/ragurney/spotless/actions/SpotlessActionOnSave.java b/src/main/java/com/github/ragurney/spotless/actions/SpotlessActionOnSave.java
new file mode 100644
index 0000000..36ce813
--- /dev/null
+++ b/src/main/java/com/github/ragurney/spotless/actions/SpotlessActionOnSave.java
@@ -0,0 +1,59 @@
+package com.github.ragurney.spotless.actions;
+
+import com.github.ragurney.spotless.config.SpotlessConfiguration;
+import com.github.ragurney.spotless.config.SpotlessOnSaveOptions;
+import com.intellij.ide.actionsOnSave.impl.ActionsOnSaveFileDocumentManagerListener;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiDocumentManager;
+import com.intellij.psi.PsiFile;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.Optional;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/** Action to be called whenever a document is saved */
+public class SpotlessActionOnSave extends ActionsOnSaveFileDocumentManagerListener.ActionOnSave {
+  public static boolean isActiveFile(
+      @NotNull PsiFile psiFile, @NotNull Project project) {
+    var virtualFile = psiFile.getVirtualFile();;
+    var fileEditorManager = FileEditorManager.getInstance(project);
+
+    return Optional.ofNullable(fileEditorManager.getSelectedTextEditor())
+        .map(Editor::getVirtualFile)
+        .filter(virtualFile::equals)
+        .isPresent();
+  }
+
+  private boolean isFileSelectedForFormatting(@NotNull PsiFile psiFile, @NotNull SpotlessOnSaveOptions options) {
+    return options.isFileTypeSelected(psiFile.getFileType());
+  }
+
+  private static @Nullable PsiFile getPsiFile(@NotNull Project project, Document editor) {
+    return PsiDocumentManager.getInstance(project).getPsiFile(editor);
+  }
+
+  @Override
+  public boolean isEnabledForProject(@NotNull Project project) {
+    return SpotlessConfiguration.getInstance(project).isRunOnSaveEnabled();
+  }
+
+  @Override
+  public void processDocuments(@NotNull Project project, @NotNull Document @NotNull [] documents) {
+    var options = SpotlessOnSaveOptions.getInstance(project);
+
+    if (!options.isRunOnSaveEnabled()) {
+      return;
+    }
+
+    Arrays.stream(documents)
+        .map(document -> getPsiFile(project, document))
+        .filter(Objects::nonNull)
+        .filter(file -> isActiveFile(file, project))
+        .filter(file -> isFileSelectedForFormatting(file, options))
+        .forEach(file -> new ReformatCodeProcessor(file).run());
+  }
+}
diff --git a/src/main/java/com/github/ragurney/spotless/config/SpotlessConfiguration.java b/src/main/java/com/github/ragurney/spotless/config/SpotlessConfiguration.java
new file mode 100644
index 0000000..1e75c00
--- /dev/null
+++ b/src/main/java/com/github/ragurney/spotless/config/SpotlessConfiguration.java
@@ -0,0 +1,43 @@
+package com.github.ragurney.spotless.config;
+
+import com.intellij.openapi.components.PersistentStateComponent;
+import com.intellij.openapi.components.State;
+import com.intellij.openapi.components.Storage;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+
+/** Configuration to store whether spotless should be executed on save */
+@State(name = "SpotlessConfiguration", storages = @Storage("spotless.xml"))
+public class SpotlessConfiguration
+    implements PersistentStateComponent<SpotlessConfiguration.State> {
+
+  private static final boolean SPOTLESS_ON_SAVE_DEFAULT = false;
+  private @NotNull State state = new State();
+
+  @NotNull
+  public static SpotlessConfiguration getInstance(@NotNull Project project) {
+    return project.getService(SpotlessConfiguration.class);
+  }
+
+  @Override
+  public @NotNull State getState() {
+    return state;
+  }
+
+  @Override
+  public void loadState(@NotNull State state) {
+    this.state = state;
+  }
+
+  public boolean isRunOnSaveEnabled() {
+    return state.runOnSave;
+  }
+
+  public void setRunOnSave(boolean runOnSave) {
+    state.runOnSave = runOnSave;
+  }
+
+  static class State {
+    public boolean runOnSave = SPOTLESS_ON_SAVE_DEFAULT;
+  }
+}
diff --git a/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveActionInfo.java b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveActionInfo.java
new file mode 100644
index 0000000..ce949be
--- /dev/null
+++ b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveActionInfo.java
@@ -0,0 +1,111 @@
+// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the
+// Apache 2.0 license.
+package com.github.ragurney.spotless.config;
+
+import com.intellij.ide.actionsOnSave.ActionOnSaveContext;
+import com.intellij.lang.Language;
+import com.intellij.lang.LanguageFormatting;
+import com.intellij.openapi.fileTypes.FileType;
+import com.intellij.openapi.fileTypes.FileTypeManager;
+import com.intellij.openapi.fileTypes.LanguageFileType;
+import com.intellij.openapi.util.Key;
+import com.intellij.psi.codeStyle.CodeStyleSettingsProvider;
+import com.intellij.psi.codeStyle.LanguageCodeStyleSettingsProvider;
+import com.intellij.ui.components.ActionLink;
+import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.MultiMap;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class SpotlessOnSaveActionInfo extends SpotlessOnSaveActionInfoBase<SpotlessOnSaveOptions> {
+
+  private static final Key<SpotlessOnSaveOptions> CURRENT_UI_STATE_KEY =
+      Key.create("spotless.format.on.save.options");
+
+  public SpotlessOnSaveActionInfo(@NotNull ActionOnSaveContext context) {
+    super(context, "Run spotless", CURRENT_UI_STATE_KEY);
+  }
+
+  @Override
+  protected @NotNull SpotlessOnSaveOptions getOptionsFromStoredState() {
+    return SpotlessOnSaveOptions.getInstance(getProject());
+  }
+
+  @Override
+  public @NotNull List<? extends ActionLink> getActionLinks() {
+    return Collections.emptyList();
+  }
+
+  @Override
+  protected void addApplicableFileTypes(@NotNull Collection<? super FileType> result) {
+    // The formatting capability of a file is generally determined by its programming language
+    // rather than its file type.
+    // The UI task involves displaying all file types that
+    //  - have the defined file name pattern (fileTypeManager.getAssociations())
+    //  - can be formatted
+    // We perform various language-based checks to assess the code's formattability.
+    // Upon successful verification, we add all associated file types for that language to the UI
+    // list.
+
+    // Another proposed solution involves displaying only the file types associated
+    // with each language aka `language.getAssociatedFileType()`.
+    // However, this approach was rejected (lost significant JS dialects),
+    // and the details can be found in the file history (CPP-37117).
+
+    // prepare the language to "file types with patterns" map
+    MultiMap<Language, LanguageFileType> languageFileTypes = new MultiMap<>();
+    FileTypeManager fileTypeManager = FileTypeManager.getInstance();
+    for (FileType fileType : fileTypeManager.getRegisteredFileTypes()) {
+      if (fileType instanceof LanguageFileType lft
+          && !fileTypeManager.getAssociations(fileType).isEmpty()) {
+        languageFileTypes.putValue(lft.getLanguage(), lft);
+      }
+    }
+
+    // if the language is formattable, add all file types from the created map
+    Consumer<Language> addLanguageFileTypes =
+        (@Nullable Language language) -> {
+          if (language != null) {
+            result.addAll(languageFileTypes.get(language));
+            ContainerUtil.addIfNotNull(result, language.getAssociatedFileType());
+          }
+        };
+
+    // add all file types that can be handled by the IDE internal formatter (== have
+    // FormattingModelBuilder)
+    for (Language language : languageFileTypes.keySet()) {
+      if (LanguageFormatting.INSTANCE.forLanguage(language) != null) {
+        addLanguageFileTypes.accept(language);
+      }
+    }
+
+    // Iterating only FormattingModelBuilders is not enough. Some file types may get formatted by
+    // external formatter integrated in the IDE (like ShExternalFormatter).
+    //
+    // A good sign that IDE supports some file type formatting is that it has a Code Style page for
+    // this file type. The following code makes
+    // sure that all file types that have their Code Style pages are included in the result set.
+    //
+    // The logic of iterating Code Style pages is similar to what's done in
+    // CodeStyleSchemesConfigurable.buildConfigurables()
+    for (CodeStyleSettingsProvider provider :
+        CodeStyleSettingsProvider.EXTENSION_POINT_NAME.getExtensionList()) {
+      if (provider.hasSettingsPage()) {
+        addLanguageFileTypes.accept(provider.getLanguage());
+      }
+    }
+    for (LanguageCodeStyleSettingsProvider provider :
+        LanguageCodeStyleSettingsProvider.getSettingsPagesProviders()) {
+      addLanguageFileTypes.accept(provider.getLanguage());
+    }
+  }
+
+  @Override
+  protected void apply() {
+    getOptionsFromStoredState().loadState(getCurrentUiState().getState().clone());
+  }
+}
diff --git a/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveActionInfoBase.java b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveActionInfoBase.java
new file mode 100644
index 0000000..ff67379
--- /dev/null
+++ b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveActionInfoBase.java
@@ -0,0 +1,252 @@
+// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the
+// Apache 2.0 license that can be found in the LICENSE file.
+
+package com.github.ragurney.spotless.config;
+
+import com.intellij.codeInsight.CodeInsightBundle;
+import com.intellij.ide.actionsOnSave.ActionOnSaveComment;
+import com.intellij.ide.actionsOnSave.ActionOnSaveContext;
+import com.intellij.ide.actionsOnSave.ActionOnSaveInfo;
+import com.intellij.openapi.fileTypes.FileType;
+import com.intellij.openapi.fileTypes.FileTypeRegistry;
+import com.intellij.openapi.ui.popup.JBPopup;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.openapi.ui.popup.JBPopupListener;
+import com.intellij.openapi.ui.popup.LightweightWindowEvent;
+import com.intellij.openapi.util.Key;
+import com.intellij.openapi.util.NlsContexts;
+import com.intellij.ui.CheckboxTree;
+import com.intellij.ui.CheckedTreeNode;
+import com.intellij.ui.TreeSpeedSearch;
+import com.intellij.ui.components.DropDownLink;
+import com.intellij.ui.components.JBScrollPane;
+import java.util.*;
+import javax.swing.*;
+import javax.swing.tree.TreeNode;
+import kotlin.jvm.functions.Function1;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public abstract class SpotlessOnSaveActionInfoBase<Options extends SpotlessOnSaveOptionsBase<?>>
+    extends ActionOnSaveInfo {
+
+  private final @NotNull @NlsContexts.Checkbox String myActionOnSaveName;
+  private final @NotNull Options myCurrentUiState;
+
+  SpotlessOnSaveActionInfoBase(
+      @NotNull ActionOnSaveContext context,
+      @NotNull @NlsContexts.Checkbox String actionOnSaveName,
+      @NotNull Key<Options> currentUiStateKey) {
+    super(context);
+    myActionOnSaveName = actionOnSaveName;
+
+    Options options = getContext().getUserData(currentUiStateKey);
+    if (options == null) {
+      //noinspection AbstractMethodCallInConstructor
+      Options storedState = getOptionsFromStoredState();
+      //noinspection unchecked
+      options = (Options) storedState.clone();
+      getContext().putUserData(currentUiStateKey, options);
+    }
+
+    myCurrentUiState = options;
+  }
+
+  protected abstract @NotNull Options getOptionsFromStoredState();
+
+  @NotNull
+  Options getCurrentUiState() {
+    return myCurrentUiState;
+  }
+
+  @Override
+  public final @NotNull @NlsContexts.Checkbox String getActionOnSaveName() {
+    return myActionOnSaveName;
+  }
+
+  @Override
+  public final boolean isActionOnSaveEnabled() {
+    return myCurrentUiState.isRunOnSaveEnabled();
+  }
+
+  @Override
+  public final void setActionOnSaveEnabled(boolean enabled) {
+    myCurrentUiState.setRunOnSaveEnabled(enabled);
+  }
+
+  @Override
+  public @Nullable ActionOnSaveComment getComment() {
+    if (myCurrentUiState.isRunOnSaveEnabled()
+        && !myCurrentUiState.isAllFileTypesSelected()
+        && myCurrentUiState.getSelectedFileTypes().isEmpty()) {
+      return ActionOnSaveComment.warning(
+          CodeInsightBundle.message("actions.on.save.page.warning.no.file.types.selected"));
+    }
+
+    return null;
+  }
+
+  @Override
+  public @NotNull List<? extends DropDownLink<?>> getDropDownLinks() {
+    return List.of(createFileTypesDropDownLink());
+  }
+
+  @NotNull
+  DropDownLink<String> createFileTypesDropDownLink() {
+    Function1<DropDownLink<String>, JBPopup> popupBuilder = this::createFileTypesPopup;
+
+    return new DropDownLink<>(getFileTypesLinkText(), popupBuilder);
+  }
+
+  private @NotNull @NlsContexts.LinkLabel String getFileTypesLinkText() {
+    if (myCurrentUiState.isAllFileTypesSelected()) {
+      return CodeInsightBundle.message("actions.on.save.page.label.all.file.types");
+    }
+
+    Set<String> fileTypes = myCurrentUiState.getSelectedFileTypes();
+
+    if (fileTypes.isEmpty()) {
+      return CodeInsightBundle.message("actions.on.save.page.label.select.file.types");
+    }
+
+    String fileTypeName = fileTypes.iterator().next();
+    FileType fileType = FileTypeRegistry.getInstance().findFileTypeByName(fileTypeName);
+    String presentableFileType = fileType != null ? fileType.getDescription() : fileTypeName;
+
+    if (fileTypes.size() == 1) {
+      return CodeInsightBundle.message(
+          "actions.on.save.page.label.one.file.type.selected", presentableFileType);
+    }
+
+    return CodeInsightBundle.message(
+        "actions.on.save.page.label.many.file.types.selected",
+        presentableFileType,
+        fileTypes.size() - 1);
+  }
+
+  private @NotNull JBPopup createFileTypesPopup(@NotNull DropDownLink<String> link) {
+    CheckedTreeNode root =
+        new CheckedTreeNode(CodeInsightBundle.message("actions.on.save.page.label.all.file.types"));
+
+    SortedSet<FileType> result =
+        new TreeSet<>(
+            Comparator.comparing(FileType::getDescription, String.CASE_INSENSITIVE_ORDER));
+    addApplicableFileTypes(result);
+
+    for (FileType fileType : result) {
+      root.add(new CheckedTreeNode(fileType));
+    }
+
+    CheckboxTree tree = createFileTypesCheckboxTree(root);
+
+    return JBPopupFactory.getInstance()
+        .createComponentPopupBuilder(new JBScrollPane(tree), tree)
+        .setRequestFocus(true)
+        .addListener(
+            new JBPopupListener() {
+              @Override
+              public void onClosed(@NotNull LightweightWindowEvent event) {
+                onFileTypePopupClosed(link, root);
+              }
+            })
+        .createPopup();
+  }
+
+  protected abstract void addApplicableFileTypes(@NotNull Collection<? super FileType> result);
+
+  private @NotNull CheckboxTree createFileTypesCheckboxTree(@NotNull CheckedTreeNode root) {
+    CheckboxTree tree =
+        new CheckboxTree(createFileTypesRenderer(), root) {
+          @Override
+          protected void installSpeedSearch() {
+            TreeSpeedSearch.installOn(
+                this,
+                false,
+                path -> {
+                  final CheckedTreeNode node = (CheckedTreeNode) path.getLastPathComponent();
+                  final Object userObject = node.getUserObject();
+                  if (userObject instanceof FileType) {
+                    return ((FileType) userObject).getDescription();
+                  }
+                  return userObject.toString();
+                });
+          }
+        };
+
+    tree.setRootVisible(true);
+    tree.setSelectionRow(0);
+
+    resetTree(root);
+
+    return tree;
+  }
+
+  private void resetTree(@NotNull CheckedTreeNode root) {
+    if (myCurrentUiState.isAllFileTypesSelected()) {
+      root.setChecked(true);
+      return;
+    }
+
+    root.setChecked(false);
+
+    Enumeration<TreeNode> fileTypesEnum = root.children();
+    while (fileTypesEnum.hasMoreElements()) {
+      CheckedTreeNode node = (CheckedTreeNode) fileTypesEnum.nextElement();
+      FileType fileType = (FileType) node.getUserObject();
+      node.setChecked(myCurrentUiState.isFileTypeSelected(fileType));
+    }
+  }
+
+  private void onFileTypePopupClosed(
+      @NotNull DropDownLink<String> link, @NotNull CheckedTreeNode root) {
+    Options options = myCurrentUiState;
+
+    if (root.isChecked()) {
+      options.setRunForAllFileTypes();
+    } else {
+      Collection<FileType> fileTypes = new ArrayList<>();
+      Enumeration<TreeNode> fileTypesEnum = root.children();
+      while (fileTypesEnum.hasMoreElements()) {
+        CheckedTreeNode node = (CheckedTreeNode) fileTypesEnum.nextElement();
+        if (node.isChecked()) {
+          fileTypes.add((FileType) node.getUserObject());
+        }
+      }
+
+      options.setRunForSelectedFileTypes(fileTypes);
+    }
+
+    link.setText(getFileTypesLinkText());
+  }
+
+  private static @NotNull CheckboxTree.CheckboxTreeCellRenderer createFileTypesRenderer() {
+    return new CheckboxTree.CheckboxTreeCellRenderer() {
+      @Override
+      public void customizeRenderer(
+          JTree t,
+          Object value,
+          boolean selected,
+          boolean expanded,
+          boolean leaf,
+          int row,
+          boolean focus) {
+        if (!(value instanceof CheckedTreeNode node)) return;
+
+        final Object userObject = node.getUserObject();
+
+        if (userObject instanceof String) {
+          getTextRenderer().append((String) userObject);
+        }
+        if (userObject instanceof FileType) {
+          getTextRenderer().setIcon(((FileType) userObject).getIcon());
+          getTextRenderer().append(((FileType) userObject).getDescription());
+        }
+      }
+    };
+  }
+
+  @Override
+  protected final boolean isModified() {
+    return !getOptionsFromStoredState().equals(myCurrentUiState);
+  }
+}
diff --git a/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveInfoProvider.java b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveInfoProvider.java
new file mode 100644
index 0000000..4ed8d9f
--- /dev/null
+++ b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveInfoProvider.java
@@ -0,0 +1,17 @@
+package com.github.ragurney.spotless.config;
+
+import com.intellij.ide.actionsOnSave.ActionOnSaveContext;
+import com.intellij.ide.actionsOnSave.ActionOnSaveInfo;
+import com.intellij.ide.actionsOnSave.ActionOnSaveInfoProvider;
+import java.util.Collection;
+import java.util.Collections;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings("UnstableApiUsage")
+public class SpotlessOnSaveInfoProvider extends ActionOnSaveInfoProvider {
+  @Override
+  protected @NotNull Collection<? extends ActionOnSaveInfo> getActionOnSaveInfos(
+      @NotNull ActionOnSaveContext context) {
+    return Collections.singleton(new SpotlessOnSaveActionInfo(context));
+  }
+}
diff --git a/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveOptions.java b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveOptions.java
new file mode 100644
index 0000000..468e93c
--- /dev/null
+++ b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveOptions.java
@@ -0,0 +1,56 @@
+// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the
+// Apache 2.0 license.
+
+package com.github.ragurney.spotless.config;
+
+import com.intellij.ide.util.PropertiesComponent;
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.components.Service.Level;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+
+@Service(Level.APP)
+@State(name = "SpotlessOnSaveOptions")
+public final class SpotlessOnSaveOptions
+    extends SpotlessOnSaveOptionsBase<SpotlessOnSaveOptions.State>
+    implements PersistentStateComponent<SpotlessOnSaveOptions.State>, Cloneable {
+
+  public static @NotNull SpotlessOnSaveOptions getInstance(@NotNull Project project) {
+    return project.getService(SpotlessOnSaveOptions.class);
+  }
+
+  static final class State extends SpotlessOnSaveOptionsBase.StateBase implements Cloneable {
+    State() {
+      super(DefaultsProvider::getFileTypesFormattedOnSaveByDefault);
+    }
+
+    @Override
+    public State clone() {
+      return (State) super.clone();
+    }
+  }
+
+  private final @NotNull Project myProject;
+
+  public SpotlessOnSaveOptions(@NotNull Project project) {
+    super(new State());
+    myProject = project;
+  }
+
+  @Override
+  protected void convertOldProperties() {
+    String oldFormatOnSaveProperty = "format.on.save";
+    boolean formatAllOld =
+        PropertiesComponent.getInstance(myProject).getBoolean(oldFormatOnSaveProperty);
+    if (formatAllOld) {
+      setRunOnSaveEnabled(true);
+      setRunForAllFileTypes();
+    }
+    PropertiesComponent.getInstance(myProject).unsetValue(oldFormatOnSaveProperty);
+  }
+
+  @Override
+  public SpotlessOnSaveOptions clone() {
+    return (SpotlessOnSaveOptions) super.clone();
+  }
+}
diff --git a/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveOptionsBase.java b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveOptionsBase.java
new file mode 100644
index 0000000..242c713
--- /dev/null
+++ b/src/main/java/com/github/ragurney/spotless/config/SpotlessOnSaveOptionsBase.java
@@ -0,0 +1,191 @@
+// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the
+// Apache 2.0 license.
+
+package com.github.ragurney.spotless.config;
+
+import com.intellij.openapi.components.PersistentStateComponent;
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.fileTypes.FileType;
+import com.intellij.util.containers.ContainerUtil;
+import java.util.*;
+import java.util.function.Function;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.VisibleForTesting;
+
+public class SpotlessOnSaveOptionsBase<S extends SpotlessOnSaveOptionsBase.StateBase>
+    implements PersistentStateComponent<S>, Cloneable {
+
+  protected static final ExtensionPointName<DefaultsProvider> EP_NAME =
+      ExtensionPointName.create("com.intellij.formatOnSaveOptions.defaultsProvider");
+
+  /**
+   * By default, the 'Reformat code' and 'Optimize imports' check boxes are unchecked on the
+   * 'Actions on Save' page, unless implementations of this interface specify a different behavior.
+   * In other words, this extension point allows having 'Reformat code' and/or 'Optimize imports'
+   * enabled out-of-the-box for the specified file types.
+   */
+  public interface DefaultsProvider {
+    default @NotNull Collection<@NotNull FileType> getFileTypesFormattedOnSaveByDefault() {
+      return Collections.emptyList();
+    }
+  }
+
+  static class StateBase implements Cloneable {
+    StateBase(
+        @NotNull
+            Function<? super DefaultsProvider, ? extends Collection<FileType>>
+                enabledByDefaultProvider) {
+      for (DefaultsProvider provider : EP_NAME.getExtensionList()) {
+        Collection<@NotNull FileType> fileTypes = enabledByDefaultProvider.apply(provider);
+        mySelectedFileTypes.addAll(ContainerUtil.map(fileTypes, FileType::getName));
+      }
+
+      if (mySelectedFileTypes.isEmpty()) {
+        // Default state when there are no extensions that want some files to be processed on save
+        // by default.
+        myRunOnSave = false;
+        myAllFileTypesSelected = true;
+      } else {
+        // Default state when extensions want some files to be precessed on save by default.
+        myRunOnSave = true;
+        myAllFileTypesSelected = false;
+      }
+    }
+
+    /** The state of the main 'Run this action on save' check box on the 'Actions on Save' page. */
+    public boolean myRunOnSave;
+
+    /**
+     * If <code>true</code> then {@link #mySelectedFileTypes} doesn't matter. This field set to
+     * <code>true</code> guarantees that 'Run this action on save' option remains enabled for all
+     * file types even if newly installed plugins contribute new file types (which obviously not yet
+     * listed in {@link #mySelectedFileTypes}).
+     */
+    public boolean myAllFileTypesSelected;
+
+    /**
+     * Contains file types (names) that have been individually selected to be processed on save.
+     * Makes sense only if {@link #myAllFileTypesSelected} is <code>false</code>.
+     */
+    public @NotNull SortedSet<@NotNull String> mySelectedFileTypes = new TreeSet<>();
+
+    @Override
+    public StateBase clone() {
+      try {
+        StateBase clone = (StateBase) super.clone();
+        clone.mySelectedFileTypes = new TreeSet<>(mySelectedFileTypes);
+        return clone;
+      } catch (CloneNotSupportedException e) {
+        throw new AssertionError();
+      }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      StateBase state = (StateBase) o;
+
+      return myRunOnSave == state.myRunOnSave
+          && myAllFileTypesSelected == state.myAllFileTypesSelected
+          && mySelectedFileTypes.equals(state.mySelectedFileTypes);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(myRunOnSave, myAllFileTypesSelected, mySelectedFileTypes);
+    }
+  }
+
+  private @NotNull S myState;
+
+  public SpotlessOnSaveOptionsBase(@NotNull S state) {
+    myState = state;
+  }
+
+  @Override
+  public final @NotNull S getState() {
+    return myState;
+  }
+
+  @Override
+  public final void loadState(@NotNull S state) {
+    myState = state;
+  }
+
+  @Override
+  public final void noStateLoaded() {
+    convertOldProperties();
+  }
+
+  protected void convertOldProperties() {}
+
+  public boolean isRunOnSaveEnabled() {
+    return myState.myRunOnSave;
+  }
+
+  @VisibleForTesting
+  public void setRunOnSaveEnabled(boolean enabled) {
+    myState.myRunOnSave = enabled;
+  }
+
+  public boolean isAllFileTypesSelected() {
+    return myState.myAllFileTypesSelected;
+  }
+
+  void setRunForAllFileTypes() {
+    myState.myAllFileTypesSelected = true;
+    myState.mySelectedFileTypes.clear();
+  }
+
+  void setRunForSelectedFileTypes(@NotNull Collection<? extends @NotNull FileType> fileTypes) {
+    myState.myAllFileTypesSelected = false;
+    myState.mySelectedFileTypes.clear();
+    for (FileType fileType : fileTypes) {
+      myState.mySelectedFileTypes.add(fileType.getName());
+    }
+  }
+
+  /**
+   * Returns {@code true} if either the root `All file types` check box is checked or the root check
+   * box is unchecked but the specific `fileType` check box is checked. <br>
+   * <br>
+   * Note that most of the callers should first call {@link #isRunOnSaveEnabled()}. The fact that
+   * `All file types` or a specific file type is checked doesn't automatically mean that the feature
+   * itself ('Run this action on save') is enabled.
+   */
+  public boolean isFileTypeSelected(@NotNull FileType fileType) {
+    return myState.myAllFileTypesSelected
+        || myState.mySelectedFileTypes.contains(fileType.getName());
+  }
+
+  Set<String> getSelectedFileTypes() {
+    return new TreeSet<>(myState.mySelectedFileTypes);
+  }
+
+  @Override
+  public SpotlessOnSaveOptionsBase<S> clone() {
+    try {
+      //noinspection unchecked
+      SpotlessOnSaveOptionsBase<S> clone = (SpotlessOnSaveOptionsBase<S>) super.clone();
+      //noinspection unchecked
+      clone.myState = (S) myState.clone();
+      return clone;
+    } catch (CloneNotSupportedException e) {
+      throw new AssertionError();
+    }
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    SpotlessOnSaveOptionsBase<?> base = (SpotlessOnSaveOptionsBase<?>) o;
+    return myState.equals(base.myState);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(myState);
+  }
+}
diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml
index 1c932ab..a429332 100644
--- a/src/main/resources/META-INF/plugin.xml
+++ b/src/main/resources/META-INF/plugin.xml
@@ -21,4 +21,14 @@
             <add-to-group group-id="CodeFormatGroup" relative-to-action="ReformatCode" anchor="before" />
         </action>
     </actions>
+
+    <extensions defaultExtensionNs="com.intellij">
+        <projectService serviceImplementation="com.github.ragurney.spotless.config.SpotlessConfiguration"/>
+        <actionOnSaveInfoProvider id="SpotlessOnSaveInfoProvider"
+                                  implementation="com.github.ragurney.spotless.config.SpotlessOnSaveInfoProvider"
+                                  order="after FormatOnSaveInfoProvider, before BuildOnSaveInfoProvider, before FileWatcherOnSaveInfoProvider, before UploadOnSaveInfoProvider"/>
+        <actionOnSave id="SpotlessActionOnSave"
+                      implementation="com.github.ragurney.spotless.actions.SpotlessActionOnSave"
+                      order="after FormatOnSaveAction"/>
+    </extensions>
 </idea-plugin>