diff --git a/CHANGELOG.md b/CHANGELOG.md
index aaa8590f40f..22ca95cdefc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 
 ### Added
 
+- We added the ability to add the current selection to a newly created group. [#11449](https://github.com/JabRef/jabref/issues/11449)
 - We added support for selecting and using CSL Styles in JabRef's OpenOffice/LibreOffice integration for inserting bibliographic and in-text citations into a document. [#2146](https://github.com/JabRef/jabref/issues/2146), [#8893](https://github.com/JabRef/jabref/issues/8893)
 - We added Tools > New library based on references in PDF file... to create a new library based on the references section in a PDF file. [#11522](https://github.com/JabRef/jabref/pull/11522)
 - When converting the references section of a paper (PDF file), more than the last page is treated. [#11522](https://github.com/JabRef/jabref/pull/11522)
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
index 06bfb4c6c41..6cc0ca5ff3e 100644
--- a/src/main/java/module-info.java
+++ b/src/main/java/module-info.java
@@ -53,7 +53,7 @@
     // endregion
 
     provides org.tinylog.writers.Writer
-    with org.jabref.gui.logging.GuiWriter;
+            with org.jabref.gui.logging.GuiWriter;
 
     // Preferences and XML
     requires java.prefs;
diff --git a/src/main/java/org/jabref/gui/StateManager.java b/src/main/java/org/jabref/gui/StateManager.java
index 792a6ba01b3..356132cdef4 100644
--- a/src/main/java/org/jabref/gui/StateManager.java
+++ b/src/main/java/org/jabref/gui/StateManager.java
@@ -76,7 +76,12 @@ public class StateManager {
     private final ObservableList<String> searchHistory = FXCollections.observableArrayList();
 
     public StateManager() {
-        activeGroups.bind(Bindings.valueAt(selectedGroups, activeDatabase.orElseOpt(null).map(BibDatabaseContext::getUid)));
+        activeGroups.bind(Bindings.valueAt(
+            selectedGroups,
+            activeDatabase
+                .orElseOpt(null)
+                .map(BibDatabaseContext::getUid))
+            .orElse(FXCollections.observableArrayList()));
     }
 
     public ObservableList<SidePaneType> getVisibleSidePaneComponents() {
@@ -162,6 +167,7 @@ public void setActiveDatabase(BibDatabaseContext database) {
             LOGGER.info("No open database detected");
             activeDatabaseProperty().set(Optional.empty());
         } else {
+            selectedGroups.computeIfAbsent(database.getUid(), k -> FXCollections.emptyObservableList());
             activeDatabaseProperty().set(Optional.of(database));
         }
     }
diff --git a/src/main/java/org/jabref/gui/actions/StandardActions.java b/src/main/java/org/jabref/gui/actions/StandardActions.java
index 1ec41a584f8..ad103f052ce 100644
--- a/src/main/java/org/jabref/gui/actions/StandardActions.java
+++ b/src/main/java/org/jabref/gui/actions/StandardActions.java
@@ -36,6 +36,7 @@ public enum StandardActions implements Action {
     EXTRACT_FILE_REFERENCES_OFFLINE(Localization.lang("Extract references from file (offline)"), IconTheme.JabRefIcons.FILE_STAR),
     OPEN_URL(Localization.lang("Open URL or DOI"), IconTheme.JabRefIcons.WWW, KeyBinding.OPEN_URL_OR_DOI),
     SEARCH_SHORTSCIENCE(Localization.lang("Search ShortScience")),
+    ADD_SUBGROUP_FROM_SELECTION(Localization.lang("Add subgroup from selection")),
     MERGE_WITH_FETCHED_ENTRY(Localization.lang("Get bibliographic data from %0", "DOI/ISBN/...")),
     ATTACH_FILE(Localization.lang("Attach file"), IconTheme.JabRefIcons.ATTACH_FILE),
     ATTACH_FILE_FROM_URL(Localization.lang("Attach file from URL"), IconTheme.JabRefIcons.DOWNLOAD_FILE),
diff --git a/src/main/java/org/jabref/gui/exporter/ExportCommand.java b/src/main/java/org/jabref/gui/exporter/ExportCommand.java
index ccf81b353ff..814d639199a 100644
--- a/src/main/java/org/jabref/gui/exporter/ExportCommand.java
+++ b/src/main/java/org/jabref/gui/exporter/ExportCommand.java
@@ -2,12 +2,12 @@
 
 import java.io.IOException;
 import java.nio.file.Path;
-import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
+import javafx.collections.FXCollections;
 import javafx.stage.FileChooser;
 import javafx.util.Duration;
 
@@ -111,7 +111,7 @@ private void export(Path file, FileChooser.ExtensionFilter selectedExtensionFilt
             // All entries
             entries = stateManager.getActiveDatabase()
                                   .map(BibDatabaseContext::getEntries)
-                                  .orElse(Collections.emptyList());
+                                  .orElse(FXCollections.emptyObservableList());
         }
 
         List<Path> fileDirForDatabase = stateManager.getActiveDatabase()
diff --git a/src/main/java/org/jabref/gui/groups/GroupDialog.fxml b/src/main/java/org/jabref/gui/groups/GroupDialog.fxml
index 02b19876250..57f2770ab67 100644
--- a/src/main/java/org/jabref/gui/groups/GroupDialog.fxml
+++ b/src/main/java/org/jabref/gui/groups/GroupDialog.fxml
@@ -102,6 +102,9 @@
                 </VBox>
                 <Separator orientation="VERTICAL"/>
                 <StackPane HBox.hgrow="ALWAYS">
+                    <VBox visible="${explicitRadioButton.selected}" spacing="10.0">
+                        <CheckBox fx:id="explicitIncludeSelected" text="%Include selected entries in created subgroup"/>
+                    </VBox>
                     <VBox visible="${keywordsRadioButton.selected}" spacing="10.0">
                         <VBox>
                             <Label text="%Field"/>
diff --git a/src/main/java/org/jabref/gui/groups/GroupDialogView.java b/src/main/java/org/jabref/gui/groups/GroupDialogView.java
index b06c26503b1..6bb6a932dfb 100644
--- a/src/main/java/org/jabref/gui/groups/GroupDialogView.java
+++ b/src/main/java/org/jabref/gui/groups/GroupDialogView.java
@@ -35,12 +35,14 @@
 import org.jabref.gui.help.HelpAction;
 import org.jabref.gui.icon.IconTheme;
 import org.jabref.gui.icon.JabrefIconProvider;
+import org.jabref.gui.maintable.Selection;
 import org.jabref.gui.util.BaseDialog;
 import org.jabref.gui.util.IconValidationDecorator;
 import org.jabref.gui.util.ViewModelListCellFactory;
 import org.jabref.logic.help.HelpFile;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.model.database.BibDatabaseContext;
+import org.jabref.model.entry.BibEntry;
 import org.jabref.model.groups.AbstractGroup;
 import org.jabref.model.groups.GroupHierarchyType;
 import org.jabref.model.groups.GroupTreeNode;
@@ -83,6 +85,8 @@ public class GroupDialogView extends BaseDialog<AbstractGroup> {
     @FXML private RadioButton texRadioButton;
 
     // Option Groups
+    @FXML private CheckBox explicitIncludeSelected;
+
     @FXML private TextField keywordGroupSearchTerm;
     @FXML private TextField keywordGroupSearchField;
     @FXML private CheckBox keywordGroupCaseSensitive;
@@ -109,6 +113,8 @@ public class GroupDialogView extends BaseDialog<AbstractGroup> {
     private final BibDatabaseContext currentDatabase;
     private final @Nullable GroupTreeNode parentNode;
     private final @Nullable AbstractGroup editedGroup;
+    private final List<BibEntry> selectedEntries;
+    private final Selection includeSelectedEntries;
 
     private GroupDialogViewModel viewModel;
 
@@ -119,10 +125,15 @@ public class GroupDialogView extends BaseDialog<AbstractGroup> {
     public GroupDialogView(BibDatabaseContext currentDatabase,
                            @Nullable GroupTreeNode parentNode,
                            @Nullable AbstractGroup editedGroup,
-                           GroupDialogHeader groupDialogHeader) {
+                           GroupDialogHeader groupDialogHeader,
+                           List<BibEntry> selectedEntries,
+                           Selection includeSelectedEntries
+    ) {
         this.currentDatabase = currentDatabase;
         this.parentNode = parentNode;
         this.editedGroup = editedGroup;
+        this.selectedEntries = selectedEntries;
+        this.includeSelectedEntries = includeSelectedEntries;
 
         ViewLoader.view(this)
                   .load()
@@ -172,7 +183,7 @@ public GroupDialogView(BibDatabaseContext currentDatabase,
 
     @FXML
     public void initialize() {
-        viewModel = new GroupDialogViewModel(dialogService, currentDatabase, preferencesService, editedGroup, parentNode, fileUpdateMonitor);
+        viewModel = new GroupDialogViewModel(dialogService, currentDatabase, preferencesService, editedGroup, parentNode, fileUpdateMonitor, selectedEntries, includeSelectedEntries);
 
         setResultConverter(viewModel::resultConverter);
 
@@ -201,6 +212,9 @@ public void initialize() {
         autoRadioButton.selectedProperty().bindBidirectional(viewModel.typeAutoProperty());
         texRadioButton.selectedProperty().bindBidirectional(viewModel.typeTexProperty());
 
+        explicitIncludeSelected.selectedProperty().bindBidirectional(viewModel.explicitIncludeSelectedProperty());
+        explicitIncludeSelected.disableProperty().bindBidirectional(viewModel.editingGroupProperty());
+
         keywordGroupSearchTerm.textProperty().bindBidirectional(viewModel.keywordGroupSearchTermProperty());
         keywordGroupSearchField.textProperty().bindBidirectional(viewModel.keywordGroupSearchFieldProperty());
         keywordGroupCaseSensitive.selectedProperty().bindBidirectional(viewModel.keywordGroupCaseSensitiveProperty());
@@ -247,7 +261,7 @@ public void initialize() {
             validationVisualizer.initVisualization(viewModel.keywordRegexValidationStatus(), keywordGroupSearchTerm);
             validationVisualizer.initVisualization(viewModel.keywordSearchTermEmptyValidationStatus(), keywordGroupSearchTerm);
             validationVisualizer.initVisualization(viewModel.keywordFieldEmptyValidationStatus(), keywordGroupSearchField);
-            validationVisualizer.initVisualization(viewModel.texGroupFilePathValidatonStatus(), texGroupFilePath);
+            validationVisualizer.initVisualization(viewModel.texGroupFilePathValidationStatus(), texGroupFilePath);
             nameField.requestFocus();
         });
 
@@ -261,10 +275,14 @@ public void initialize() {
                 viewModel.colorFieldProperty().setValue(IconTheme.getDefaultGroupColor());
                 return;
             }
-            List<Color> colorsOfSiblings = parentNode.getChildren().stream().map(child -> child.getGroup().getColor())
-                                                     .flatMap(Optional::stream)
-                                                     .toList();
-            Optional<Color> parentColor = parentGroup().getColor();
+
+            List<Color> colorsOfSiblings = parentNode.getChildren()
+                    .stream()
+                    .map(GroupTreeNode::getGroup)
+                    .map(AbstractGroup::getColor)
+                    .flatMap(Optional::stream)
+                    .toList();
+            Optional<Color> parentColor = parentNode.getGroup().getColor();
             Color color;
             color = parentColor.map(value -> GroupColorPicker.generateColor(colorsOfSiblings, value)).orElseGet(() -> GroupColorPicker.generateColor(colorsOfSiblings));
             viewModel.colorFieldProperty().setValue(color);
diff --git a/src/main/java/org/jabref/gui/groups/GroupDialogViewModel.java b/src/main/java/org/jabref/gui/groups/GroupDialogViewModel.java
index 73f671e65e2..ab66cfcbc12 100644
--- a/src/main/java/org/jabref/gui/groups/GroupDialogViewModel.java
+++ b/src/main/java/org/jabref/gui/groups/GroupDialogViewModel.java
@@ -25,6 +25,7 @@
 
 import org.jabref.gui.DialogService;
 import org.jabref.gui.icon.IconTheme;
+import org.jabref.gui.maintable.Selection;
 import org.jabref.gui.util.FileDialogConfiguration;
 import org.jabref.logic.auxparser.DefaultAuxParser;
 import org.jabref.logic.groups.DefaultGroupsFactory;
@@ -33,6 +34,7 @@
 import org.jabref.logic.util.io.FileUtil;
 import org.jabref.model.database.BibDatabase;
 import org.jabref.model.database.BibDatabaseContext;
+import org.jabref.model.entry.BibEntry;
 import org.jabref.model.entry.Keyword;
 import org.jabref.model.entry.field.FieldFactory;
 import org.jabref.model.groups.AbstractGroup;
@@ -77,6 +79,10 @@ public class GroupDialogViewModel {
     private final BooleanProperty typeAutoProperty = new SimpleBooleanProperty();
     private final BooleanProperty typeTexProperty = new SimpleBooleanProperty();
 
+    // Explicit Groups
+    private final BooleanProperty explicitIncludeSelectedProperty = new SimpleBooleanProperty(false);
+    private final BooleanProperty editingGroupProperty = new SimpleBooleanProperty(false);
+
     // Option Groups
     private final StringProperty keywordGroupSearchTermProperty = new SimpleStringProperty("");
     private final StringProperty keywordGroupSearchFieldProperty = new SimpleStringProperty("");
@@ -112,24 +118,42 @@ public class GroupDialogViewModel {
     private final AbstractGroup editedGroup;
     private final GroupTreeNode parentNode;
     private final FileUpdateMonitor fileUpdateMonitor;
+    private final List<BibEntry> selectedEntries;
+    private final Selection includeSelectedEntries;
 
     public GroupDialogViewModel(DialogService dialogService,
                                 BibDatabaseContext currentDatabase,
                                 PreferencesService preferencesService,
                                 @Nullable AbstractGroup editedGroup,
                                 @Nullable GroupTreeNode parentNode,
-                                FileUpdateMonitor fileUpdateMonitor) {
+                                FileUpdateMonitor fileUpdateMonitor,
+                                List<BibEntry> selectedEntries,
+                                Selection includeSelectedEntries
+    ) {
         this.dialogService = dialogService;
         this.preferencesService = preferencesService;
         this.currentDatabase = currentDatabase;
         this.editedGroup = editedGroup;
         this.parentNode = parentNode;
         this.fileUpdateMonitor = fileUpdateMonitor;
+        this.selectedEntries = selectedEntries;
+        this.includeSelectedEntries = includeSelectedEntries;
 
         setupValidation();
         setValues();
     }
 
+    public GroupDialogViewModel(
+            DialogService dialogService,
+            BibDatabaseContext currentDatabase,
+            PreferencesService preferencesService,
+            @Nullable AbstractGroup editedGroup,
+            @Nullable GroupTreeNode parentNode,
+            FileUpdateMonitor fileUpdateMonitor
+    ) {
+        this(dialogService, currentDatabase, preferencesService, editedGroup, parentNode, fileUpdateMonitor, new ArrayList<>(), Selection.IGNORE_SELECTED_ENTRIES);
+    }
+
     private void setupValidation() {
         validator = new CompositeValidator();
 
@@ -246,7 +270,7 @@ private void setupValidation() {
                             return false;
                         }
                         return FileUtil.getFileExtension(input)
-                                .map(extension -> "aux".equalsIgnoreCase(extension))
+                                .map("aux"::equalsIgnoreCase)
                                 .orElse(false);
                     }
                 },
@@ -311,9 +335,13 @@ public AbstractGroup resultConverter(ButtonType button) {
             String groupName = nameProperty.getValue().trim();
             if (typeExplicitProperty.getValue()) {
                 resultingGroup = new ExplicitGroup(
-                        groupName,
-                        groupHierarchySelectedProperty.getValue(),
-                        preferencesService.getBibEntryPreferences().getKeywordSeparator());
+                    groupName,
+                    groupHierarchySelectedProperty.getValue(),
+                    preferencesService.getBibEntryPreferences().getKeywordSeparator()
+                );
+                if (explicitIncludeSelectedProperty.getValue()) {
+                    ((ExplicitGroup) resultingGroup).add(selectedEntries);
+                }
             } else if (typeKeywordsProperty.getValue()) {
                 if (keywordGroupRegexProperty.getValue()) {
                     resultingGroup = new RegexKeywordGroup(
@@ -372,7 +400,6 @@ public AbstractGroup resultConverter(ButtonType button) {
                         fileUpdateMonitor,
                         currentDatabase.getMetaData());
             }
-
             if (resultingGroup != null) {
                 preferencesService.getGroupsPreferences().setDefaultHierarchicalContext(groupHierarchySelectedProperty.getValue());
 
@@ -391,7 +418,7 @@ public AbstractGroup resultConverter(ButtonType button) {
 
     public void setValues() {
         groupHierarchyListProperty.setValue(FXCollections.observableArrayList(GroupHierarchyType.values()));
-
+        explicitIncludeSelectedProperty.setValue(includeSelectedEntries == Selection.INCLUDE_SELECTED_ENTRIES || preferencesService.getGroupsPreferences().shouldAutoIncludeSelected());
         if (editedGroup == null) {
             // creating new group -> defaults!
             // TODO: Create default group (via org.jabref.logic.groups.DefaultGroupsFactory) and use values
@@ -415,6 +442,7 @@ public void setValues() {
             descriptionProperty.setValue(editedGroup.getDescription().orElse(""));
             iconProperty.setValue(editedGroup.getIconName().orElse(""));
             groupHierarchySelectedProperty.setValue(editedGroup.getHierarchicalContext());
+            editingGroupProperty.setValue(true);
 
             if (editedGroup.getClass() == WordKeywordGroup.class) {
                 typeKeywordsProperty.setValue(true);
@@ -454,11 +482,6 @@ public void setValues() {
                     autoGroupPersonsOptionProperty.setValue(Boolean.TRUE);
                     autoGroupPersonsFieldProperty.setValue(group.getField().getName());
                 }
-            } else if (editedGroup.getClass() == TexGroup.class) {
-                typeTexProperty.setValue(true);
-
-                TexGroup group = (TexGroup) editedGroup;
-                texGroupFilePathProperty.setValue(group.getFilePath().toString());
             }
         }
     }
@@ -492,7 +515,7 @@ public void texGroupBrowse() {
     }
 
     private List<Path> getFileDirectoriesAsPaths() {
-        List<Path> fileDirs = new ArrayList<>();
+        List<Path> fileDirs = List.of();
         MetaData metaData = currentDatabase.getMetaData();
         metaData.getLatexFileDirectory(preferencesService.getFilePreferences().getUserAndHost()).ifPresent(fileDirs::add);
 
@@ -535,7 +558,7 @@ public ValidationStatus keywordSearchTermEmptyValidationStatus() {
         return keywordSearchTermEmptyValidator.getValidationStatus();
     }
 
-    public ValidationStatus texGroupFilePathValidatonStatus() {
+    public ValidationStatus texGroupFilePathValidationStatus() {
         return texGroupFilePathValidator.getValidationStatus();
     }
 
@@ -587,6 +610,14 @@ public BooleanProperty typeTexProperty() {
         return typeTexProperty;
     }
 
+    public BooleanProperty explicitIncludeSelectedProperty() {
+        return explicitIncludeSelectedProperty;
+    }
+
+    public BooleanProperty editingGroupProperty() {
+        return editingGroupProperty;
+    }
+
     public StringProperty keywordGroupSearchTermProperty() {
         return keywordGroupSearchTermProperty;
     }
diff --git a/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java b/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java
index 75ce49baf99..e7f55a2652b 100644
--- a/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java
+++ b/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java
@@ -52,7 +52,7 @@
 
 public class GroupNodeViewModel {
 
-    private final String displayName;
+    private String displayName;
     private final boolean isRoot;
     private final ObservableList<GroupNodeViewModel> children;
     private final BibDatabaseContext databaseContext;
@@ -65,10 +65,11 @@ public class GroupNodeViewModel {
     private final BooleanBinding allSelectedEntriesMatched;
     private final TaskExecutor taskExecutor;
     private final CustomLocalDragboard localDragBoard;
-    private final ObservableList<BibEntry> entriesList;
     private final PreferencesService preferencesService;
     private final InvalidationListener onInvalidatedGroup = listener -> refreshGroup();
 
+    private final ObservableList<BibEntry> entriesList;
+
     public GroupNodeViewModel(BibDatabaseContext databaseContext, StateManager stateManager, TaskExecutor taskExecutor, GroupTreeNode groupNode, CustomLocalDragboard localDragBoard, PreferencesService preferencesService) {
         this.databaseContext = Objects.requireNonNull(databaseContext);
         this.taskExecutor = Objects.requireNonNull(taskExecutor);
@@ -76,15 +77,17 @@ public GroupNodeViewModel(BibDatabaseContext databaseContext, StateManager state
         this.groupNode = Objects.requireNonNull(groupNode);
         this.localDragBoard = Objects.requireNonNull(localDragBoard);
         this.preferencesService = preferencesService;
-
-        displayName = new LatexToUnicodeFormatter().format(groupNode.getName());
+        LatexToUnicodeFormatter formatter = new LatexToUnicodeFormatter();
+        groupNode.nameSubscription(name -> displayName = formatter.format(name));
         isRoot = groupNode.isRoot();
         if (groupNode.getGroup() instanceof AutomaticGroup automaticGroup) {
-            children = automaticGroup.createSubgroups(this.databaseContext.getDatabase().getEntries())
-                                     .stream()
-                                     .map(this::toViewModel)
-                                     .sorted((group1, group2) -> group1.getDisplayName().compareToIgnoreCase(group2.getDisplayName()))
-                                     .collect(Collectors.toCollection(FXCollections::observableArrayList));
+            children = automaticGroup
+                .createSubgroups(this.databaseContext.getDatabase().getEntries())
+                .stream()
+                .map(this::toViewModel)
+                .sorted((group1, group2) -> group1.getDisplayName().compareToIgnoreCase(group2.getDisplayName()))
+                .collect(Collectors.toCollection(FXCollections::observableArrayList));
+            children.forEach(c -> groupNode.addChild(c.getGroupNode()));
         } else {
             children = EasyBind.mapBacked(groupNode.getChildren(), this::toViewModel);
         }
@@ -93,19 +96,29 @@ public GroupNodeViewModel(BibDatabaseContext databaseContext, StateManager state
         }
         hasChildren = new SimpleBooleanProperty();
         hasChildren.bind(Bindings.isNotEmpty(children));
+
         EasyBind.subscribe(preferencesService.getGroupsPreferences().displayGroupCountProperty(), shouldDisplay -> updateMatchedEntries());
+        if (stateManager.activeGroupProperty() != null && !stateManager.activeGroupProperty().isEmpty()) {
+            this.updateMatchedEntries();
+        }
+        stateManager.activeGroupProperty().subscribe(this::updateMatchedEntries);
+
         expandedProperty.set(groupNode.getGroup().isExpanded());
         expandedProperty.addListener((observable, oldValue, newValue) -> groupNode.getGroup().setExpanded(newValue));
 
         // Register listener
-        // The wrapper created by the FXCollections will set a weak listener on the wrapped list. This weak listener gets garbage collected. Hence, we need to maintain a reference to this list.
+        // The wrapper created by the FXCollections will set a weak listener on the wrapped list.
+        // This weak listener gets garbage collected. Hence, we need to maintain a reference to this list.
         entriesList = databaseContext.getDatabase().getEntries();
-        entriesList.addListener(this::onDatabaseChanged);
+        entriesList.addListener(this::onEntriesChanged);
 
-        EasyObservableList<Boolean> selectedEntriesMatchStatus = EasyBind.map(stateManager.getSelectedEntries(), groupNode::matches);
-        anySelectedEntriesMatched = selectedEntriesMatchStatus.anyMatch(matched -> matched);
+        EasyObservableList<Boolean> selectedEntriesMatchStatus = EasyBind.map(
+                this.stateManager.getSelectedEntries(),
+                this.groupNode::matches
+        );
         // 'all' returns 'true' for empty streams, so this has to be checked explicitly
-        allSelectedEntriesMatched = selectedEntriesMatchStatus.isEmptyBinding().not().and(selectedEntriesMatchStatus.allMatch(matched -> matched));
+        allSelectedEntriesMatched = selectedEntriesMatchStatus.allMatch(matched -> matched).and(selectedEntriesMatchStatus.isEmptyBinding().not());
+        anySelectedEntriesMatched = selectedEntriesMatchStatus.anyMatch(matched -> matched);
     }
 
     public GroupNodeViewModel(BibDatabaseContext databaseContext, StateManager stateManager, TaskExecutor taskExecutor, AbstractGroup group, CustomLocalDragboard localDragboard, PreferencesService preferencesService) {
@@ -190,7 +203,7 @@ public String toString() {
         return "GroupNodeViewModel{" +
                 "displayName='" + displayName + '\'' +
                 ", isRoot=" + isRoot +
-                ", icon='" + getIcon() + '\'' +
+                ", icon='" + getIcon().name() + '\'' +
                 ", children=" + children +
                 ", databaseContext=" + databaseContext +
                 ", groupNode=" + groupNode +
@@ -229,15 +242,18 @@ public GroupTreeNode getGroupNode() {
     /**
      * Gets invoked if an entry in the current database changes.
      */
-    private void onDatabaseChanged(ListChangeListener.Change<? extends BibEntry> change) {
+    private void onEntriesChanged(ListChangeListener.Change<? extends BibEntry> change) {
         while (change.next()) {
             if (change.wasPermutated()) {
-                // Nothing to do, as permutation doesn't change matched entries
+                // do nothing
             } else if (change.wasUpdated()) {
                 for (BibEntry changedEntry : change.getList().subList(change.getFrom(), change.getTo())) {
                     if (groupNode.matches(changedEntry)) {
                         if (!matchedEntries.contains(changedEntry)) {
                             matchedEntries.add(changedEntry);
+                        } else if (matchedEntries.stream().map(BibEntry::getId).noneMatch(changedEntry.getId()::equals)) {
+                            // Deals with potentially-identical newly created entries
+                            matchedEntries.add(changedEntry);
                         }
                     } else {
                         matchedEntries.remove(changedEntry);
@@ -248,8 +264,10 @@ private void onDatabaseChanged(ListChangeListener.Change<? extends BibEntry> cha
                     matchedEntries.remove(removedEntry);
                 }
                 for (BibEntry addedEntry : change.getAddedSubList()) {
-                    if (groupNode.matches(addedEntry)) {
-                        if (!matchedEntries.contains(addedEntry)) {
+                    // Check for ID equality, otherwise new entries with no field info aren't added
+                    // and entry count doesn't increment.
+                    if (matchedEntries.stream().noneMatch(e -> e.getId().equals(addedEntry.getId()))) {
+                        if (groupNode.matches(addedEntry)) {
                             matchedEntries.add(addedEntry);
                         }
                     }
@@ -389,7 +407,7 @@ public boolean canAddEntriesIn() {
             return true;
         } else if (group instanceof LastNameGroup || group instanceof RegexKeywordGroup) {
             return groupNode.getParent()
-                            .map(parent -> parent.getGroup())
+                            .map(GroupTreeNode::getGroup)
                             .map(groupParent -> groupParent instanceof AutomaticKeywordGroup || groupParent instanceof AutomaticPersonsGroup)
                             .orElse(false);
         } else if (group instanceof KeywordGroup) {
@@ -492,7 +510,7 @@ public boolean isEditable() {
         } else if (group instanceof KeywordGroup) {
             // KeywordGroup is parent of LastNameGroup, RegexKeywordGroup and WordKeywordGroup
             return groupNode.getParent()
-                            .map(parent -> parent.getGroup())
+                            .map(GroupTreeNode::getGroup)
                             .map(groupParent -> !(groupParent instanceof AutomaticKeywordGroup || groupParent instanceof AutomaticPersonsGroup))
                             .orElse(false);
         } else if (group instanceof SearchGroup) {
diff --git a/src/main/java/org/jabref/gui/groups/GroupTreeView.java b/src/main/java/org/jabref/gui/groups/GroupTreeView.java
index ef837d2586e..ac5a0ca2fe5 100644
--- a/src/main/java/org/jabref/gui/groups/GroupTreeView.java
+++ b/src/main/java/org/jabref/gui/groups/GroupTreeView.java
@@ -5,15 +5,16 @@
 import java.text.DecimalFormat;
 import java.time.Duration;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
-import javafx.application.Platform;
 import javafx.beans.binding.Bindings;
 import javafx.beans.property.ObjectProperty;
+import javafx.collections.ObservableList;
 import javafx.css.PseudoClass;
 import javafx.geometry.Orientation;
 import javafx.scene.Node;
@@ -59,8 +60,10 @@
 import org.jabref.gui.util.ViewModelTreeTableCellFactory;
 import org.jabref.gui.util.ViewModelTreeTableRowFactory;
 import org.jabref.logic.l10n.Localization;
+import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.entry.BibEntry;
 import org.jabref.model.groups.AllEntriesGroup;
+import org.jabref.model.groups.GroupTreeNode;
 import org.jabref.preferences.PreferencesService;
 
 import com.tobiasdiez.easybind.EasyBind;
@@ -172,17 +175,23 @@ private void initialize() {
         groupTree.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
         dragExpansionHandler = new DragExpansionHandler();
 
-        // Set-up bindings
-        Platform.runLater(() ->
-                BindingsHelper.bindContentBidirectional(
-                        groupTree.getSelectionModel().getSelectedItems(),
-                        viewModel.selectedGroupsProperty(),
-                        newSelectedGroups -> {
-                            groupTree.getSelectionModel().clearSelection();
-                            newSelectedGroups.forEach(this::selectNode);
-                        },
-                        this::updateSelection
-                ));
+        BindingsHelper.bindContentBidirectional(
+            groupTree.getSelectionModel().getSelectedItems(),
+            stateManager.activeGroupProperty(),
+            this::selectActiveNodes,
+            model -> {
+                // activeGroupProperty is read-only, so we update it by proxy
+                // by updating stateManager.getSelectedGroups(database),
+                // which propagates back to activeGroupProperty.
+                if (stateManager.getActiveDatabase().isPresent()) {
+                    updateSelection(
+                        model.stream().map(TreeItem::getValue)
+                            .map(GroupNodeViewModel::getGroupNode)
+                            .collect(Collectors.toList()),
+                        stateManager.getActiveDatabase().get()
+                    );
+                }
+            });
 
         // We try to prevent publishing changes in the search field directly to the search task that takes some time
         // for larger group structures.
@@ -192,19 +201,23 @@ private void initialize() {
         });
         searchField.textProperty().addListener((observable, oldValue, newValue) -> searchTask.restart());
 
-        groupTree.rootProperty().bind(
-                EasyBind.map(viewModel.rootGroupProperty(),
-                        group -> {
-                            if (group == null) {
-                                return null;
-                            } else {
-                                return new RecursiveTreeItem<>(
-                                        group,
-                                        GroupNodeViewModel::getChildren,
-                                        GroupNodeViewModel::expandedProperty,
-                                        viewModel.filterPredicateProperty());
-                            }
-                        }));
+        // Binding these values causes some issues with update order which
+        // lead to the active groups not being highlighted.
+        EasyBind.subscribe(stateManager.activeDatabaseProperty(),
+                database -> {
+                    viewModel.setNewDatabase(database);
+                    groupTree.rootProperty().setValue(
+                        viewModel.rootGroup() != null
+                            ? new RecursiveTreeItem<>(
+                                viewModel.rootGroup(),
+                                GroupNodeViewModel::getChildren,
+                                GroupNodeViewModel::expandedProperty,
+                                viewModel.filterPredicateProperty())
+                            : null
+                    );
+                    database.ifPresent(bibDatabaseContext -> selectActiveNodes(stateManager.activeGroupProperty()));
+                }
+            );
 
         // Icon and group name
         new ViewModelTreeTableCellFactory<GroupNodeViewModel>()
@@ -231,7 +244,7 @@ private void initialize() {
                 .withContextMenu(this::createContextMenuForGroup)
                 .withEventFilter(MouseEvent.MOUSE_PRESSED, (row, event) -> {
                     if (((MouseEvent) event).getButton() == MouseButton.SECONDARY && !stateManager.getSelectedEntries().isEmpty()) {
-                        // Prevent right-click to select group whe we have selected entries
+                        // Prevent right-click to select group when we have selected entries
                         event.consume();
                     } else if (event.getTarget() instanceof StackPane pane) {
                         if (pane.getStyleClass().contains("arrow") || pane.getStyleClass().contains("tree-disclosure-node")) {
@@ -283,19 +296,7 @@ private StackPane createNumberCell(GroupNodeViewModel group) {
         }
         Text text = new Text();
         EasyBind.subscribe(preferencesService.getGroupsPreferences().displayGroupCountProperty(),
-                shouldDisplayGroupCount -> {
-                    if (text.textProperty().isBound()) {
-                        text.textProperty().unbind();
-                        text.setText("");
-                    }
-
-                    if (shouldDisplayGroupCount) {
-                        text.textProperty().bind(group.getHits().map(Number::intValue).map(this::getFormattedNumber));
-                        Tooltip tooltip = new Tooltip();
-                        tooltip.textProperty().bind(group.getHits().asString());
-                        Tooltip.install(text, tooltip);
-                    }
-                });
+                shouldDisplayGroupCount -> refreshDisplayGroupCountText(text, group));
         text.getStyleClass().setAll("text");
 
         text.styleProperty().bind(Bindings.createStringBinding(() -> {
@@ -319,6 +320,20 @@ private StackPane createNumberCell(GroupNodeViewModel group) {
         return node;
     }
 
+    private void refreshDisplayGroupCountText(Text text, GroupNodeViewModel group) {
+        if (text.textProperty().isBound()) {
+            text.textProperty().unbind();
+            text.setText("");
+        }
+
+        if (preferencesService.getGroupsPreferences().displayGroupCountProperty().getValue()) {
+            text.textProperty().bind(group.getHits().map(Number::intValue).map(this::getFormattedNumber));
+            Tooltip tooltip = new Tooltip();
+            tooltip.textProperty().bind(group.getHits().asString());
+            Tooltip.install(text, tooltip);
+        }
+    }
+
     private void handleOnDragExited(TreeTableRow<GroupNodeViewModel> row, GroupNodeViewModel fieldViewModel, DragEvent dragEvent) {
         ControlHelper.removeDroppingPseudoClasses(row);
     }
@@ -354,7 +369,7 @@ private void handleOnDragDropped(TreeTableRow<GroupNodeViewModel> row, GroupNode
             List<GroupNodeViewModel> changedGroups = new LinkedList<>();
             for (String pathToSource : pathToSources) {
                 Optional<GroupNodeViewModel> source = viewModel
-                        .rootGroupProperty().get()
+                        .rootGroup()
                         .getChildByPath(pathToSource);
                 if (source.isPresent() && source.get().canBeDragged()) {
                     source.get().draggedOn(row.getItem(), ControlHelper.getDroppingMouseLocation(row, event));
@@ -363,7 +378,7 @@ private void handleOnDragDropped(TreeTableRow<GroupNodeViewModel> row, GroupNode
                 }
             }
             groupTree.getSelectionModel().clearSelection();
-            changedGroups.forEach(value -> selectNode(value, true));
+            changedGroups.forEach(value -> selectNode(value.getGroupNode(), true));
             if (success) {
                 viewModel.writeGroupChangesToMetaData();
             }
@@ -394,20 +409,31 @@ private void handleOnDragOver(TreeTableRow<GroupNodeViewModel> row, GroupNodeVie
         }
     }
 
-    private void updateSelection(List<TreeItem<GroupNodeViewModel>> newSelectedGroups) {
-        if ((newSelectedGroups == null) || newSelectedGroups.isEmpty()) {
-            viewModel.selectedGroupsProperty().clear();
+    private void updateSelection(List<GroupTreeNode> newActiveGroups, BibDatabaseContext database) {
+        if (newActiveGroups == null) {
+            stateManager.setSelectedGroups(database, Collections.singletonList(viewModel.rootGroup().getGroupNode()));
         } else {
-            List<GroupNodeViewModel> list = newSelectedGroups.stream().filter(model -> (model != null) && !(model.getValue().getGroupNode().getGroup() instanceof AllEntriesGroup)).map(TreeItem::getValue).collect(Collectors.toList());
-            viewModel.selectedGroupsProperty().setAll(list);
+            List<GroupTreeNode> list = newActiveGroups.stream()
+                    .filter(model -> (model != null) && !(model.getGroup() instanceof AllEntriesGroup))
+                    .collect(Collectors.toList());
+            stateManager.setSelectedGroups(database, list);
+        }
+    }
+
+    private void selectActiveNodes(ObservableList<GroupTreeNode> activeGroups) {
+        groupTree.getSelectionModel().clearSelection();
+        if (activeGroups != null && !activeGroups.isEmpty()) {
+            activeGroups.forEach(this::selectNode);
+        } else if (viewModel.rootGroup() != null) {
+            this.selectNode(viewModel.rootGroup().getGroupNode(), true);
         }
     }
 
-    private void selectNode(GroupNodeViewModel value) {
+    private void selectNode(GroupTreeNode value) {
         selectNode(value, false);
     }
 
-    private void selectNode(GroupNodeViewModel value, boolean expandParents) {
+    private void selectNode(GroupTreeNode value, boolean expandParents) {
         getTreeItemByValue(value)
                 .ifPresent(treeItem -> {
                     if (expandParents) {
@@ -421,17 +447,17 @@ private void selectNode(GroupNodeViewModel value, boolean expandParents) {
                 });
     }
 
-    private Optional<TreeItem<GroupNodeViewModel>> getTreeItemByValue(GroupNodeViewModel value) {
+    private Optional<TreeItem<GroupNodeViewModel>> getTreeItemByValue(GroupTreeNode value) {
         return getTreeItemByValue(groupTree.getRoot(), value);
     }
 
     private Optional<TreeItem<GroupNodeViewModel>> getTreeItemByValue(TreeItem<GroupNodeViewModel> root,
-                                                                      GroupNodeViewModel value) {
+                                                                      GroupTreeNode value) {
         if (root == null) {
             return Optional.empty();
         }
 
-        if (root.getValue().equals(value)) {
+        if (root.getValue().getGroupNode().equals(value)) {
             return Optional.of(root);
         }
 
@@ -663,11 +689,11 @@ public void execute() {
                 case GROUP_REMOVE_WITH_SUBGROUPS ->
                         viewModel.removeGroupAndSubgroups(group);
                 case GROUP_EDIT -> {
-                    viewModel.editGroup(group);
+                    viewModel.editGroup(group.getGroupNode());
                     groupTree.refresh();
                 }
                 case GROUP_SUBGROUP_ADD ->
-                        viewModel.addNewSubgroup(group, GroupDialogHeader.SUBGROUP);
+                        viewModel.addNewSubgroup(group);
                 case GROUP_SUBGROUP_REMOVE ->
                         viewModel.removeSubgroups(group);
                 case GROUP_SUBGROUP_SORT ->
diff --git a/src/main/java/org/jabref/gui/groups/GroupTreeViewModel.java b/src/main/java/org/jabref/gui/groups/GroupTreeViewModel.java
index ae7dcc241fd..342601c3928 100644
--- a/src/main/java/org/jabref/gui/groups/GroupTreeViewModel.java
+++ b/src/main/java/org/jabref/gui/groups/GroupTreeViewModel.java
@@ -7,38 +7,29 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 
 import javafx.beans.property.ListProperty;
 import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyListProperty;
 import javafx.beans.property.SimpleListProperty;
 import javafx.beans.property.SimpleObjectProperty;
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.property.StringProperty;
 import javafx.collections.FXCollections;
-import javafx.collections.ObservableList;
-import javafx.scene.control.Alert;
-import javafx.scene.control.ButtonBar;
-import javafx.scene.control.ButtonType;
+import javafx.collections.ListChangeListener;
 
 import org.jabref.gui.AbstractViewModel;
 import org.jabref.gui.DialogService;
 import org.jabref.gui.StateManager;
+import org.jabref.gui.maintable.CreateGroupAction;
+import org.jabref.gui.maintable.Selection;
 import org.jabref.gui.util.CustomLocalDragboard;
 import org.jabref.gui.util.TaskExecutor;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.entry.BibEntry;
-import org.jabref.model.groups.AbstractGroup;
-import org.jabref.model.groups.AutomaticKeywordGroup;
-import org.jabref.model.groups.AutomaticPersonsGroup;
 import org.jabref.model.groups.ExplicitGroup;
 import org.jabref.model.groups.GroupTreeNode;
-import org.jabref.model.groups.RegexKeywordGroup;
-import org.jabref.model.groups.SearchGroup;
-import org.jabref.model.groups.TexGroup;
-import org.jabref.model.groups.WordKeywordGroup;
-import org.jabref.model.metadata.MetaData;
 import org.jabref.preferences.PreferencesService;
 
 import com.tobiasdiez.easybind.EasyBind;
@@ -46,7 +37,7 @@
 public class GroupTreeViewModel extends AbstractViewModel {
 
     private final ObjectProperty<GroupNodeViewModel> rootGroup = new SimpleObjectProperty<>();
-    private final ListProperty<GroupNodeViewModel> selectedGroups = new SimpleListProperty<>(FXCollections.observableArrayList());
+    private final ListProperty<GroupTreeNode> selectedGroups = new SimpleListProperty<>(FXCollections.observableArrayList());
     private final StateManager stateManager;
     private final DialogService dialogService;
     private final PreferencesService preferences;
@@ -61,44 +52,88 @@ public class GroupTreeViewModel extends AbstractViewModel {
             .getName()
             .compareToIgnoreCase(v1.getName());
     private final Comparator<GroupTreeNode> compEntries = (GroupTreeNode v1, GroupTreeNode v2) -> {
-        int numChildren1 = v1.getEntriesInGroup(this.currentDatabase.get().getEntries()).size();
-        int numChildren2 = v2.getEntriesInGroup(this.currentDatabase.get().getEntries()).size();
-        return Integer.compare(numChildren2, numChildren1);
+        if (this.currentDatabase.isPresent()) {
+            int numChildren1 = v1.getEntriesInGroup(this.currentDatabase.get().getEntries()).size();
+            int numChildren2 = v2.getEntriesInGroup(this.currentDatabase.get().getEntries()).size();
+            return Integer.compare(numChildren2, numChildren1);
+        }
+            return 0;
     };
     private final Comparator<GroupTreeNode> compEntriesReverse = (GroupTreeNode v1, GroupTreeNode v2) -> {
-        int numChildren1 = v1.getEntriesInGroup(this.currentDatabase.get().getEntries()).size();
-        int numChildren2 = v2.getEntriesInGroup(this.currentDatabase.get().getEntries()).size();
-        return Integer.compare(numChildren1, numChildren2);
+        if (this.currentDatabase.isPresent()) {
+            int numChildren1 = v1.getEntriesInGroup(this.currentDatabase.get().getEntries()).size();
+            int numChildren2 = v2.getEntriesInGroup(this.currentDatabase.get().getEntries()).size();
+            return Integer.compare(numChildren1, numChildren2);
+        }
+        return 0;
     };
     private Optional<BibDatabaseContext> currentDatabase = Optional.empty();
 
-    public GroupTreeViewModel(StateManager stateManager, DialogService dialogService, PreferencesService preferencesService, TaskExecutor taskExecutor, CustomLocalDragboard localDragboard) {
+    public GroupTreeViewModel(StateManager stateManager,
+                              DialogService dialogService,
+                              PreferencesService preferencesService,
+                              TaskExecutor taskExecutor,
+                              CustomLocalDragboard localDragboard) {
         this.stateManager = Objects.requireNonNull(stateManager);
         this.dialogService = Objects.requireNonNull(dialogService);
         this.preferences = Objects.requireNonNull(preferencesService);
         this.taskExecutor = Objects.requireNonNull(taskExecutor);
         this.localDragboard = Objects.requireNonNull(localDragboard);
 
-        // Register listener
-        EasyBind.subscribe(stateManager.activeDatabaseProperty(), this::onActiveDatabaseChanged);
-        EasyBind.subscribe(selectedGroups, this::onSelectedGroupChanged);
-
         // Set-up bindings
         filterPredicate.bind(EasyBind.map(filterText, text -> group -> group.isMatchedBy(text)));
 
+        ReadOnlyListProperty<GroupTreeNode> list = stateManager.activeGroupProperty();
+        Optional<BibDatabaseContext> database = stateManager.getActiveDatabase();
+        selectedGroups.setAll(list);
+        list.addListener(this::onActiveGroupChange);
+
         // Init
-        refresh();
+        setNewDatabase(stateManager.getActiveDatabase());
+        database.ifPresent(
+            bibDatabaseContext ->
+                stateManager.setSelectedGroups(
+                    bibDatabaseContext,
+                    Collections.singletonList(rootGroup.get().getGroupNode()
+        )));
     }
 
-    private void refresh() {
-        onActiveDatabaseChanged(stateManager.activeDatabaseProperty().getValue());
+    /**
+     * Gets invoked if the user selects a different group.
+     * We need to notify the {@link StateManager} about this change so that the main table gets updated.
+     */
+    private void onActiveGroupChange(ListChangeListener.Change<? extends GroupTreeNode> newValue) {
+        if (!currentDatabase.equals(stateManager.activeDatabaseProperty().getValue())) {
+            // Active database is not this one: do nothing
+            return;
+        }
+
+        currentDatabase.ifPresent(database -> {
+            if (newValue == null) {
+                selectedGroups.clear();
+            } else {
+                selectedGroups.setAll(newValue.getList());
+            }
+        });
+    }
+
+    public void setNewDatabase(BibDatabaseContext database) {
+        setNewDatabase(Optional.ofNullable(database));
     }
 
-    public ObjectProperty<GroupNodeViewModel> rootGroupProperty() {
-        return rootGroup;
+    public void setNewDatabase(Optional<BibDatabaseContext> database) {
+        currentDatabase = database;
+        database.ifPresentOrElse(
+                this::onActiveDatabaseExists,
+                this::onActiveDatabaseNull
+        );
     }
 
-    public ListProperty<GroupNodeViewModel> selectedGroupsProperty() {
+    public GroupNodeViewModel rootGroup() {
+        return rootGroup.get();
+    }
+
+    public ListProperty<GroupTreeNode> selectedGroupsProperty() {
         return selectedGroups;
     }
 
@@ -110,278 +145,60 @@ public StringProperty filterTextProperty() {
         return filterText;
     }
 
-    /**
-     * Gets invoked if the user selects a different group.
-     * We need to notify the {@link StateManager} about this change so that the main table gets updated.
-     */
-    private void onSelectedGroupChanged(ObservableList<GroupNodeViewModel> newValue) {
-        if (!currentDatabase.equals(stateManager.activeDatabaseProperty().getValue())) {
-            // Switch of database occurred -> do nothing
-            return;
-        }
-
-        currentDatabase.ifPresent(database -> {
-            if ((newValue == null) || newValue.isEmpty()) {
-                stateManager.clearSelectedGroups(database);
-            } else {
-                stateManager.setSelectedGroups(database, newValue.stream().map(GroupNodeViewModel::getGroupNode).collect(Collectors.toList()));
-            }
-        });
-    }
-
     /**
      * Opens "New Group Dialog" and add the resulting group to the root
      */
     public void addNewGroupToRoot() {
-        if (currentDatabase.isPresent()) {
-            addNewSubgroup(rootGroup.get(), GroupDialogHeader.GROUP);
-        } else {
-            dialogService.showWarningDialogAndWait(Localization.lang("Cannot create group"), Localization.lang("Cannot create group. Please create a library first."));
-        }
+        CreateGroupAction groupMaker = new CreateGroupAction(
+                dialogService,
+                stateManager,
+                rootGroup.get().getGroupNode(),
+                null,
+                Selection.IGNORE_SELECTED_ENTRIES
+        );
+        groupMaker.execute();
     }
 
     /**
      * Gets invoked if the user changes the active database.
-     * We need to get the new group tree and update the view
+     * We need to get the new group tree
      */
-    private void onActiveDatabaseChanged(Optional<BibDatabaseContext> newDatabase) {
-        if (newDatabase.isPresent()) {
-            GroupNodeViewModel newRoot = newDatabase
-                    .map(BibDatabaseContext::getMetaData)
-                    .flatMap(MetaData::getGroups)
-                    .map(root -> new GroupNodeViewModel(newDatabase.get(), stateManager, taskExecutor, root, localDragboard, preferences))
-                    .orElse(GroupNodeViewModel.getAllEntriesGroup(newDatabase.get(), stateManager, taskExecutor, localDragboard, preferences));
-
-            rootGroup.setValue(newRoot);
-            if (stateManager.getSelectedGroups(newDatabase.get()).isEmpty()) {
-                stateManager.setSelectedGroups(newDatabase.get(), Collections.singletonList(newRoot.getGroupNode()));
-            }
-            selectedGroups.setAll(
-                    stateManager.getSelectedGroups(newDatabase.get()).stream()
-                                .map(selectedGroup -> new GroupNodeViewModel(newDatabase.get(), stateManager, taskExecutor, selectedGroup, localDragboard, preferences))
-                                .collect(Collectors.toList()));
-        } else {
-            rootGroup.setValue(null);
-        }
-        currentDatabase = newDatabase;
+    private void onActiveDatabaseExists(BibDatabaseContext newDatabase) {
+        GroupNodeViewModel newRoot = newDatabase.getMetaData().getGroups()
+                .map(root -> new GroupNodeViewModel(newDatabase, stateManager, taskExecutor, root, localDragboard, preferences))
+                .orElse(GroupNodeViewModel.getAllEntriesGroup(newDatabase, stateManager, taskExecutor, localDragboard, preferences));
+
+        rootGroup.setValue(newRoot);
+    }
+
+    private void onActiveDatabaseNull() {
+        rootGroup.setValue(null);
     }
 
     /**
      * Opens "New Group Dialog" and adds the resulting group as subgroup to the specified group
      */
-    public void addNewSubgroup(GroupNodeViewModel parent, GroupDialogHeader groupDialogHeader) {
-        currentDatabase.ifPresent(database -> {
-            Optional<AbstractGroup> newGroup = dialogService.showCustomDialogAndWait(new GroupDialogView(
-                    database,
-                    parent.getGroupNode(),
-                    null,
-                    groupDialogHeader));
-
-            newGroup.ifPresent(group -> {
-                GroupTreeNode newSubgroup = parent.addSubgroup(group);
-                selectedGroups.setAll(new GroupNodeViewModel(database, stateManager, taskExecutor, newSubgroup, localDragboard, preferences));
-
-                // TODO: Add undo
-                // UndoableAddOrRemoveGroup undo = new UndoableAddOrRemoveGroup(parent, new GroupTreeNodeViewModel(newGroupNode), UndoableAddOrRemoveGroup.ADD_NODE);
-                // panel.getUndoManager().addEdit(undo);
-
-                // TODO: Expand parent to make new group visible
-                // parent.expand();
-                dialogService.notify(Localization.lang("Added group \"%0\".", group.getName()));
-                writeGroupChangesToMetaData();
-            });
-        });
+    public void addNewSubgroup(GroupNodeViewModel parent) {
+        CreateGroupAction groupMaker = new CreateGroupAction(dialogService, stateManager);
+        groupMaker.execute();
     }
 
     public void writeGroupChangesToMetaData() {
         currentDatabase.ifPresent(database -> database.getMetaData().setGroups(rootGroup.get().getGroupNode()));
     }
 
-    private boolean isGroupTypeEqual(AbstractGroup oldGroup, AbstractGroup newGroup) {
-        return oldGroup.getClass().equals(newGroup.getClass());
-    }
-
-    /**
-     * Check if it is necessary to show a group modified, reassign entry dialog <br>
-     * Group name change is handled separately
-     *
-     * @param oldGroup Original Group
-     * @param newGroup Edited group
-     * @return true if just trivial modifications (e.g. color or description) or the relevant group properties are equal, false otherwise
-     */
-    boolean onlyMinorChanges(AbstractGroup oldGroup, AbstractGroup newGroup) {
-        // we need to use getclass here because we have different subclass inheritance e.g. ExplicitGroup is a subclass of WordKeyWordGroup
-        if (oldGroup.getClass() == WordKeywordGroup.class) {
-            WordKeywordGroup oldWordKeywordGroup = (WordKeywordGroup) oldGroup;
-            WordKeywordGroup newWordKeywordGroup = (WordKeywordGroup) newGroup;
-
-            return Objects.equals(oldWordKeywordGroup.getSearchField().getName(), newWordKeywordGroup.getSearchField().getName())
-                    && Objects.equals(oldWordKeywordGroup.getSearchExpression(), newWordKeywordGroup.getSearchExpression())
-                    && Objects.equals(oldWordKeywordGroup.isCaseSensitive(), newWordKeywordGroup.isCaseSensitive());
-        } else if (oldGroup.getClass() == RegexKeywordGroup.class) {
-            RegexKeywordGroup oldRegexKeywordGroup = (RegexKeywordGroup) oldGroup;
-            RegexKeywordGroup newRegexKeywordGroup = (RegexKeywordGroup) newGroup;
-
-            return Objects.equals(oldRegexKeywordGroup.getSearchField().getName(), newRegexKeywordGroup.getSearchField().getName())
-                    && Objects.equals(oldRegexKeywordGroup.getSearchExpression(), newRegexKeywordGroup.getSearchExpression())
-                    && Objects.equals(oldRegexKeywordGroup.isCaseSensitive(), newRegexKeywordGroup.isCaseSensitive());
-        } else if (oldGroup.getClass() == SearchGroup.class) {
-            SearchGroup oldSearchGroup = (SearchGroup) oldGroup;
-            SearchGroup newSearchGroup = (SearchGroup) newGroup;
-
-            return Objects.equals(oldSearchGroup.getSearchExpression(), newSearchGroup.getSearchExpression())
-                    && Objects.equals(oldSearchGroup.getSearchFlags(), newSearchGroup.getSearchFlags());
-        } else if (oldGroup.getClass() == AutomaticKeywordGroup.class) {
-            AutomaticKeywordGroup oldAutomaticKeywordGroup = (AutomaticKeywordGroup) oldGroup;
-            AutomaticKeywordGroup newAutomaticKeywordGroup = (AutomaticKeywordGroup) oldGroup;
-
-            return Objects.equals(oldAutomaticKeywordGroup.getKeywordDelimiter(), newAutomaticKeywordGroup.getKeywordDelimiter())
-                    && Objects.equals(oldAutomaticKeywordGroup.getKeywordHierarchicalDelimiter(), newAutomaticKeywordGroup.getKeywordHierarchicalDelimiter())
-                    && Objects.equals(oldAutomaticKeywordGroup.getField().getName(), newAutomaticKeywordGroup.getField().getName());
-        } else if (oldGroup.getClass() == AutomaticPersonsGroup.class) {
-            AutomaticPersonsGroup oldAutomaticPersonsGroup = (AutomaticPersonsGroup) oldGroup;
-            AutomaticPersonsGroup newAutomaticPersonsGroup = (AutomaticPersonsGroup) newGroup;
-
-            return Objects.equals(oldAutomaticPersonsGroup.getField().getName(), newAutomaticPersonsGroup.getField().getName());
-        } else if (oldGroup.getClass() == TexGroup.class) {
-            TexGroup oldTexGroup = (TexGroup) oldGroup;
-            TexGroup newTexGroup = (TexGroup) newGroup;
-            return Objects.equals(oldTexGroup.getFilePath().toString(), newTexGroup.getFilePath().toString());
-        }
-        return true;
-    }
-
     /**
      * Opens "Edit Group Dialog" and changes the given group to the edited one.
      */
-    public void editGroup(GroupNodeViewModel oldGroup) {
-        currentDatabase.ifPresent(database -> {
-            Optional<AbstractGroup> newGroup = dialogService.showCustomDialogAndWait(new GroupDialogView(
-                    database,
-                    oldGroup.getGroupNode().getParent().orElse(null),
-                    oldGroup.getGroupNode().getGroup(),
-                    GroupDialogHeader.SUBGROUP));
-            newGroup.ifPresent(group -> {
-
-                AbstractGroup oldGroupDef = oldGroup.getGroupNode().getGroup();
-                String oldGroupName = oldGroupDef.getName();
-
-                boolean groupTypeEqual = isGroupTypeEqual(oldGroupDef, group);
-                boolean onlyMinorModifications = groupTypeEqual && onlyMinorChanges(oldGroupDef, group);
-
-                // dialog already warns us about this if the new group is named like another existing group
-                // We need to check if only the name changed as this is relevant for the entry's group field
-                if (groupTypeEqual && !group.getName().equals(oldGroupName) && onlyMinorModifications) {
-                    int groupsWithSameName = 0;
-                    Optional<GroupTreeNode> databaseRootGroup = currentDatabase.get().getMetaData().getGroups();
-                    if (databaseRootGroup.isPresent()) {
-                        // we need to check the old name for duplicates. If the new group name occurs more than once, it won't matter
-                        groupsWithSameName = databaseRootGroup.get().findChildrenSatisfying(g -> g.getName().equals(oldGroupName)).size();
-                    }
-                    boolean removePreviousAssignments = true;
-                    // We found more than 2 groups, so we cannot simply remove old assignment
-                    if (groupsWithSameName >= 2) {
-                        removePreviousAssignments = false;
-                    }
-
-                    oldGroup.getGroupNode().setGroup(
-                            group,
-                            true,
-                            removePreviousAssignments,
-                            database.getEntries());
-
-                    dialogService.notify(Localization.lang("Modified group \"%0\".", group.getName()));
-                    writeGroupChangesToMetaData();
-                    // This is ugly but we have no proper update mechanism in place to propagate the changes, so redraw everything
-                    refresh();
-                    return;
-                }
-
-                if (groupTypeEqual && onlyMinorChanges(oldGroup.getGroupNode().getGroup(), group)) {
-                    oldGroup.getGroupNode().setGroup(
-                            group,
-                            true,
-                            true,
-                            database.getEntries());
-
-                    writeGroupChangesToMetaData();
-                    refresh();
-                    return;
-                }
-
-                // Major modifications
-
-                String content = Localization.lang("Assign the original group's entries to this group?");
-                ButtonType keepAssignments = new ButtonType(Localization.lang("Assign"), ButtonBar.ButtonData.YES);
-                ButtonType removeAssignments = new ButtonType(Localization.lang("Do not assign"), ButtonBar.ButtonData.NO);
-                ButtonType cancel = new ButtonType(Localization.lang("Cancel"), ButtonBar.ButtonData.CANCEL_CLOSE);
-
-                if (newGroup.get().getClass() == WordKeywordGroup.class) {
-                    content = content + "\n\n" +
-                            Localization.lang("(Note: If original entries lack keywords to qualify for the new group configuration, confirming here will add them)");
-                }
-                Optional<ButtonType> previousAssignments = dialogService.showCustomButtonDialogAndWait(Alert.AlertType.WARNING,
-                        Localization.lang("Change of Grouping Method"),
-                        content,
-                        keepAssignments,
-                        removeAssignments,
-                        cancel);
-                boolean removePreviousAssignments = (oldGroup.getGroupNode().getGroup() instanceof ExplicitGroup)
-                        && (group instanceof ExplicitGroup);
-
-                int groupsWithSameName = 0;
-                Optional<GroupTreeNode> databaseRootGroup = currentDatabase.get().getMetaData().getGroups();
-                if (databaseRootGroup.isPresent()) {
-                    String name = oldGroup.getGroupNode().getGroup().getName();
-                    groupsWithSameName = databaseRootGroup.get().findChildrenSatisfying(g -> g.getName().equals(name)).size();
-                }
-                // okay we found more than 2 groups with the same name
-                // If we only found one we can still do it
-                if (groupsWithSameName >= 2) {
-                    removePreviousAssignments = false;
-                }
-
-                if (previousAssignments.isPresent() && (previousAssignments.get().getButtonData() == ButtonBar.ButtonData.YES)) {
-                    oldGroup.getGroupNode().setGroup(
-                            group,
-                            true,
-                            removePreviousAssignments,
-                            database.getEntries());
-                } else if (previousAssignments.isPresent() && (previousAssignments.get().getButtonData() == ButtonBar.ButtonData.NO)) {
-                    oldGroup.getGroupNode().setGroup(
-                            group,
-                            false,
-                            removePreviousAssignments,
-                            database.getEntries());
-                } else if (previousAssignments.isPresent() && (previousAssignments.get().getButtonData() == ButtonBar.ButtonData.CANCEL_CLOSE)) {
-                    return;
-                }
-
-                // stateManager.getEntriesInCurrentDatabase());
-
-                // TODO: Add undo
-                // Store undo information.
-                // AbstractUndoableEdit undoAddPreviousEntries = null;
-                // UndoableModifyGroup undo = new UndoableModifyGroup(GroupSelector.this, groupsRoot, node, newGroup);
-                // if (undoAddPreviousEntries == null) {
-                //    panel.getUndoManager().addEdit(undo);
-                // } else {
-                //    NamedCompound nc = new NamedCompound("Modify Group");
-                //    nc.addEdit(undo);
-                //    nc.addEdit(undoAddPreviousEntries);
-                //    nc.end();/
-                //      panel.getUndoManager().addEdit(nc);
-                // }
-                // if (!addChange.isEmpty()) {
-                //    undoAddPreviousEntries = UndoableChangeEntriesOfGroup.getUndoableEdit(null, addChange);
-                // }
-
-                dialogService.notify(Localization.lang("Modified group \"%0\".", group.getName()));
-                writeGroupChangesToMetaData();
-                // This is ugly but we have no proper update mechanism in place to propagate the changes, so redraw everything
-                refresh();
-            });
-        });
+    public void editGroup(GroupTreeNode oldGroup) {
+        GroupTreeNode parent;
+        if (oldGroup.getParent().isEmpty()) {
+            parent = rootGroup.get().getGroupNode();
+        } else {
+            parent = oldGroup.getParent().get();
+        }
+        CreateGroupAction groupMaker = new CreateGroupAction(dialogService, stateManager, parent, oldGroup, Selection.IGNORE_SELECTED_ENTRIES);
+        groupMaker.execute();
     }
 
     public void removeSubgroups(GroupNodeViewModel group) {
@@ -393,7 +210,7 @@ public void removeSubgroups(GroupNodeViewModel group) {
             // final UndoableModifySubtree undo = new UndoableModifySubtree(getGroupTreeRoot(), node, "Remove subgroups");
             // panel.getUndoManager().addEdit(undo);
             for (GroupNodeViewModel child : group.getChildren()) {
-                removeGroupsAndSubGroupsFromEntries(child);
+                removeGroupsAndSubGroupsFromEntries(child.getGroupNode());
             }
             group.getGroupNode().removeAllChildren();
             dialogService.notify(Localization.lang("Removed all subgroups of group \"%0\".", group.getDisplayName()));
@@ -420,13 +237,11 @@ public void removeGroupKeepSubgroups(GroupNodeViewModel group) {
             // final UndoableAddOrRemoveGroup undo = new UndoableAddOrRemoveGroup(groupsRoot, node, UndoableAddOrRemoveGroup.REMOVE_NODE_KEEP_CHILDREN);
             // panel.getUndoManager().addEdit(undo);
 
-            List<GroupNodeViewModel> selectedGroupNodes = new ArrayList<>(selectedGroups);
+            List<GroupTreeNode> selectedGroupNodes = new ArrayList<>(selectedGroups);
             selectedGroupNodes.forEach(eachNode -> {
-                GroupTreeNode groupNode = eachNode.getGroupNode();
-
-                groupNode.getParent()
-                         .ifPresent(parent -> groupNode.moveAllChildrenTo(parent, parent.getIndexOfChild(groupNode).get()));
-                groupNode.removeFromParent();
+                eachNode.getParent()
+                         .ifPresent(parent -> eachNode.moveAllChildrenTo(parent, parent.getIndexOfChild(eachNode).get()));
+                eachNode.removeFromParent();
             });
 
             if (selectedGroupNodes.size() > 1) {
@@ -460,10 +275,10 @@ public void removeGroupAndSubgroups(GroupNodeViewModel group) {
             // final UndoableAddOrRemoveGroup undo = new UndoableAddOrRemoveGroup(groupsRoot, node, UndoableAddOrRemoveGroup.REMOVE_NODE_AND_CHILDREN);
             // panel.getUndoManager().addEdit(undo);
 
-            ArrayList<GroupNodeViewModel> selectedGroupNodes = new ArrayList<>(selectedGroups);
+            ArrayList<GroupTreeNode> selectedGroupNodes = new ArrayList<>(selectedGroups);
             selectedGroupNodes.forEach(eachNode -> {
                 removeGroupsAndSubGroupsFromEntries(eachNode);
-                eachNode.getGroupNode().removeFromParent();
+                eachNode.removeFromParent();
             });
 
             if (selectedGroupNodes.size() > 1) {
@@ -497,10 +312,10 @@ public void removeGroupNoSubgroups(GroupNodeViewModel group) {
             // final UndoableAddOrRemoveGroup undo = new UndoableAddOrRemoveGroup(groupsRoot, node, UndoableAddOrRemoveGroup.REMOVE_NODE_WITHOUT_CHILDREN);
             // panel.getUndoManager().addEdit(undo);
 
-            ArrayList<GroupNodeViewModel> selectedGroupNodes = new ArrayList<>(selectedGroups);
+            ArrayList<GroupTreeNode> selectedGroupNodes = new ArrayList<>(selectedGroups);
             selectedGroupNodes.forEach(eachNode -> {
                 removeGroupsAndSubGroupsFromEntries(eachNode);
-                eachNode.getGroupNode().removeFromParent();
+                eachNode.removeFromParent();
             });
 
             if (selectedGroupNodes.size() > 1) {
@@ -512,22 +327,22 @@ public void removeGroupNoSubgroups(GroupNodeViewModel group) {
         }
     }
 
-    void removeGroupsAndSubGroupsFromEntries(GroupNodeViewModel group) {
-        for (GroupNodeViewModel child : group.getChildren()) {
+    void removeGroupsAndSubGroupsFromEntries(GroupTreeNode group) {
+        for (GroupTreeNode child : group.getChildren()) {
             removeGroupsAndSubGroupsFromEntries(child);
         }
 
         // only remove explicit groups from the entries, keyword groups should not be deleted
-        if (group.getGroupNode().getGroup() instanceof ExplicitGroup) {
+        if (currentDatabase.isPresent() && group.getGroup() instanceof ExplicitGroup) {
             int groupsWithSameName = 0;
-            String name = group.getGroupNode().getGroup().getName();
+            String name = group.getGroup().getName();
             Optional<GroupTreeNode> rootGroup = currentDatabase.get().getMetaData().getGroups();
             if (rootGroup.isPresent()) {
                 groupsWithSameName = rootGroup.get().findChildrenSatisfying(g -> g.getName().equals(name)).size();
             }
             if (groupsWithSameName < 2) {
-                List<BibEntry> entriesInGroup = group.getGroupNode().getEntriesInGroup(this.currentDatabase.get().getEntries());
-                group.getGroupNode().removeEntriesFromGroup(entriesInGroup);
+                List<BibEntry> entriesInGroup = group.getEntriesInGroup(this.currentDatabase.get().getEntries());
+                group.removeEntriesFromGroup(entriesInGroup);
             }
         }
     }
diff --git a/src/main/java/org/jabref/gui/groups/GroupsPreferences.java b/src/main/java/org/jabref/gui/groups/GroupsPreferences.java
index e83d5546daa..5debb513757 100644
--- a/src/main/java/org/jabref/gui/groups/GroupsPreferences.java
+++ b/src/main/java/org/jabref/gui/groups/GroupsPreferences.java
@@ -12,16 +12,19 @@ public class GroupsPreferences {
     private final ObjectProperty<GroupViewMode> groupViewMode;
     private final BooleanProperty shouldAutoAssignGroup;
     private final BooleanProperty shouldDisplayGroupCount;
+    private final BooleanProperty shouldAutoIncludeSelected;
     private final ObjectProperty<GroupHierarchyType> defaultHierarchicalContext;
 
     public GroupsPreferences(GroupViewMode groupViewMode,
                              boolean shouldAutoAssignGroup,
                              boolean shouldDisplayGroupCount,
+                             boolean shouldAutoIncludeSelected,
                              GroupHierarchyType defaultHierarchicalContext) {
 
         this.groupViewMode = new SimpleObjectProperty<>(groupViewMode);
         this.shouldAutoAssignGroup = new SimpleBooleanProperty(shouldAutoAssignGroup);
         this.shouldDisplayGroupCount = new SimpleBooleanProperty(shouldDisplayGroupCount);
+        this.shouldAutoIncludeSelected = new SimpleBooleanProperty(shouldAutoIncludeSelected);
         this.defaultHierarchicalContext = new SimpleObjectProperty<>(defaultHierarchicalContext);
     }
 
@@ -72,4 +75,16 @@ public ObjectProperty<GroupHierarchyType> defaultHierarchicalContextProperty() {
     public void setDefaultHierarchicalContext(GroupHierarchyType defaultHierarchicalContext) {
         this.defaultHierarchicalContext.set(defaultHierarchicalContext);
     }
+
+    public BooleanProperty autoIncludeSelectedProperty() {
+        return shouldAutoIncludeSelected;
+    }
+
+    public boolean shouldAutoIncludeSelected() {
+        return shouldAutoIncludeSelected.getValue();
+    }
+
+    public void setAutoIncludeSelected(boolean shouldAutoIncludeSelected) {
+        this.shouldAutoIncludeSelected.set(shouldAutoIncludeSelected);
+    }
 }
diff --git a/src/main/java/org/jabref/gui/maintable/CreateGroupAction.java b/src/main/java/org/jabref/gui/maintable/CreateGroupAction.java
new file mode 100644
index 00000000000..df8e85fedba
--- /dev/null
+++ b/src/main/java/org/jabref/gui/maintable/CreateGroupAction.java
@@ -0,0 +1,249 @@
+package org.jabref.gui.maintable;
+
+import java.util.Collections;
+import java.util.Objects;
+import java.util.Optional;
+
+import javafx.scene.control.Alert;
+import javafx.scene.control.ButtonBar;
+import javafx.scene.control.ButtonType;
+
+import org.jabref.gui.DialogService;
+import org.jabref.gui.StateManager;
+import org.jabref.gui.actions.SimpleCommand;
+import org.jabref.gui.groups.GroupDialogHeader;
+import org.jabref.gui.groups.GroupDialogView;
+import org.jabref.logic.l10n.Localization;
+import org.jabref.model.database.BibDatabaseContext;
+import org.jabref.model.groups.AbstractGroup;
+import org.jabref.model.groups.AutomaticKeywordGroup;
+import org.jabref.model.groups.AutomaticPersonsGroup;
+import org.jabref.model.groups.ExplicitGroup;
+import org.jabref.model.groups.GroupTreeNode;
+import org.jabref.model.groups.RegexKeywordGroup;
+import org.jabref.model.groups.SearchGroup;
+import org.jabref.model.groups.TexGroup;
+import org.jabref.model.groups.WordKeywordGroup;
+import org.jabref.model.metadata.MetaData;
+
+import org.jspecify.annotations.Nullable;
+
+public class CreateGroupAction extends SimpleCommand {
+
+    private final DialogService dialogService;
+    private final StateManager stateManager;
+    private final GroupTreeNode editGroup;
+    private final GroupTreeNode prospectiveParent;
+    private final Optional<BibDatabaseContext> database;
+    private final Selection includeSelection;
+
+    public CreateGroupAction(
+            DialogService dialogService,
+            StateManager stateManager,
+            @Nullable GroupTreeNode parentGroup,
+            @Nullable GroupTreeNode editGroup,
+            Selection includeSelection
+    ) {
+        this.dialogService = dialogService;
+        this.stateManager = stateManager;
+        this.editGroup = editGroup;
+        this.includeSelection = includeSelection;
+
+        database = stateManager.getActiveDatabase();
+
+        if (editGroup != null && editGroup.getParent().isPresent()) {
+            prospectiveParent = editGroup.getParent().get();
+        } else {
+            prospectiveParent = parentGroup;
+        }
+    }
+
+    public CreateGroupAction(
+        DialogService dialogService,
+        StateManager stateManager
+    ) {
+        this(dialogService, stateManager, stateManager.getActiveDatabase().map(BibDatabaseContext::getMetaData).map(MetaData::getGroups).get().get(), null, Selection.IGNORE_SELECTED_ENTRIES);
+    }
+
+    public void writeGroupChangesToMetaData(BibDatabaseContext database, GroupTreeNode newGroup) {
+        database.getMetaData().setGroups(newGroup.getRoot());
+    }
+
+    @Override
+    public void execute() {
+        if (database.isEmpty() || prospectiveParent == null) {
+            dialogService.showWarningDialogAndWait(Localization.lang("Cannot create group"), Localization.lang("Cannot create group. Please create a library first."));
+            return;
+        }
+
+        Optional<AbstractGroup> newGroup = dialogService.showCustomDialogAndWait(
+                new GroupDialogView(
+                        database.get(),
+                        prospectiveParent,
+                        editGroup != null ? editGroup.getGroup() : null,
+                        prospectiveParent.isRoot() ? GroupDialogHeader.GROUP : GroupDialogHeader.SUBGROUP,
+                        stateManager.getSelectedEntries(),
+                        includeSelection
+                ));
+
+        newGroup.ifPresent(group -> {
+            GroupTreeNode newSubgroup;
+            if (editGroup != null) {
+                Optional<GroupTreeNode> editedGroup = groupEditActions(editGroup, group, database.get());
+                if (editedGroup.isEmpty()) {
+                    return;
+                }
+                newSubgroup = editedGroup.get();
+                dialogService.notify(Localization.lang("Modified group \"%0\".", newSubgroup.getName()));
+            } else {
+                newSubgroup = prospectiveParent.addSubgroup(group);
+                dialogService.notify(Localization.lang("Added group \"%0\".", newSubgroup.getName()));
+            }
+
+            // TODO: Add undo
+            // UndoableAddOrRemoveGroup undo = new UndoableAddOrRemoveGroup(parent, new GroupTreeNodeViewModel(newGroupNode), UndoableAddOrRemoveGroup.ADD_NODE);
+            // panel.getUndoManager().addEdit(undo);
+            writeGroupChangesToMetaData(database.get(), newSubgroup);
+            stateManager.setSelectedGroups(database.get(), Collections.singletonList(newSubgroup));
+        });
+    }
+
+    private Optional<GroupTreeNode> groupEditActions(GroupTreeNode node, AbstractGroup newGroup, BibDatabaseContext database) {
+        AbstractGroup oldGroup = node.getGroup();
+        String oldGroupName = oldGroup.getName();
+
+        boolean groupTypeEqual = isGroupTypeEqual(oldGroup, newGroup);
+        boolean onlyMinorModifications = groupTypeEqual && changesAreMinor(oldGroup, newGroup);
+
+        // I inherited this from the previous maintainer. Haven't dug into which has better priority,
+        // what default behavior is, or why this appears replicated -- all my changes are simply refactoring.
+        boolean keepPreviousAssignments;
+        boolean removePreviousAssignments;
+
+        // dialog already warns us about this if the new group is named like another existing group
+        // We need to check if only the name changed as this is relevant for the entry's group field
+        if (groupTypeEqual && !newGroup.getName().equals(oldGroupName) && onlyMinorModifications) {
+            keepPreviousAssignments = true;
+            // If the name is unique, we want to remove the old database with the same name.
+            // Otherwise, we need to keep them.
+            removePreviousAssignments = nameIsUnique(oldGroup, newGroup, database);
+        } else if (onlyMinorModifications) {
+            keepPreviousAssignments = true;
+            removePreviousAssignments = true;
+        } else {
+            // Major modifications
+            Optional<ButtonType> reassignmentResponse = showConfirmationPanel(newGroup.getClass() == WordKeywordGroup.class);
+            if (reassignmentResponse.isEmpty() || reassignmentResponse.get().getButtonData() == ButtonBar.ButtonData.CANCEL_CLOSE) {
+                return Optional.empty();
+            }
+            removePreviousAssignments = (node.getGroup() instanceof ExplicitGroup)
+                    && (newGroup instanceof ExplicitGroup)
+                    && nameIsUnique(oldGroup, newGroup, database);
+            keepPreviousAssignments = reassignmentResponse.get().getButtonData() == ButtonBar.ButtonData.YES;
+        }
+        // TODO: Add undo
+        // Store undo information.
+        // AbstractUndoableEdit undoAddPreviousEntries = null;
+        // UndoableModifyGroup undo = new UndoableModifyGroup(GroupSelector.this, groupsRoot, node, newGroup);
+        // if (undoAddPreviousEntries == null) {
+        //    panel.getUndoManager().addEdit(undo);
+        // } else {
+        //    NamedCompound nc = new NamedCompound("Modify Group");
+        //    nc.addEdit(undo);
+        //    nc.addEdit(undoAddPreviousEntries);
+        //    nc.end();/
+        //      panel.getUndoManager().addEdit(nc);
+        // }
+        // if (!addChange.isEmpty()) {
+        //    undoAddPreviousEntries = UndoableChangeEntriesOfGroup.getUndoableEdit(null, addChange);
+        // }
+        node.setGroup(
+                newGroup,
+                keepPreviousAssignments,
+                removePreviousAssignments,
+                database.getEntries());
+        return Optional.of(node);
+    }
+
+    private boolean isGroupTypeEqual(AbstractGroup oldGroup, AbstractGroup newGroup) {
+        return oldGroup.getClass().equals(newGroup.getClass());
+    }
+
+    /**
+     * Check if it is necessary to show a group modified, reassign entry dialog <br>
+     * Group name change is handled separately
+     *
+     * @param oldGroup Original Group
+     * @param newGroup Edited group
+     * @return true if just trivial modifications (e.g. color or description) or the relevant group properties are equal, false otherwise
+     */
+    public static boolean changesAreMinor(AbstractGroup oldGroup, AbstractGroup newGroup) {
+        // we need to use getclass here because we have different subclass inheritance e.g. ExplicitGroup is a subclass of WordKeyWordGroup
+        if (oldGroup.getClass() == WordKeywordGroup.class) {
+            WordKeywordGroup oldWordKeywordGroup = (WordKeywordGroup) oldGroup;
+            WordKeywordGroup newWordKeywordGroup = (WordKeywordGroup) newGroup;
+
+            return Objects.equals(oldWordKeywordGroup.getSearchField().getName(), newWordKeywordGroup.getSearchField().getName())
+                    && Objects.equals(oldWordKeywordGroup.getSearchExpression(), newWordKeywordGroup.getSearchExpression())
+                    && Objects.equals(oldWordKeywordGroup.isCaseSensitive(), newWordKeywordGroup.isCaseSensitive());
+        } else if (oldGroup.getClass() == RegexKeywordGroup.class) {
+            RegexKeywordGroup oldRegexKeywordGroup = (RegexKeywordGroup) oldGroup;
+            RegexKeywordGroup newRegexKeywordGroup = (RegexKeywordGroup) newGroup;
+
+            return Objects.equals(oldRegexKeywordGroup.getSearchField().getName(), newRegexKeywordGroup.getSearchField().getName())
+                    && Objects.equals(oldRegexKeywordGroup.getSearchExpression(), newRegexKeywordGroup.getSearchExpression())
+                    && Objects.equals(oldRegexKeywordGroup.isCaseSensitive(), newRegexKeywordGroup.isCaseSensitive());
+        } else if (oldGroup.getClass() == SearchGroup.class) {
+            SearchGroup oldSearchGroup = (SearchGroup) oldGroup;
+            SearchGroup newSearchGroup = (SearchGroup) newGroup;
+
+            return Objects.equals(oldSearchGroup.getSearchExpression(), newSearchGroup.getSearchExpression())
+                    && Objects.equals(oldSearchGroup.getSearchFlags(), newSearchGroup.getSearchFlags());
+        } else if (oldGroup.getClass() == AutomaticKeywordGroup.class) {
+            AutomaticKeywordGroup oldAutomaticKeywordGroup = (AutomaticKeywordGroup) oldGroup;
+            AutomaticKeywordGroup newAutomaticKeywordGroup = (AutomaticKeywordGroup) oldGroup;
+
+            return Objects.equals(oldAutomaticKeywordGroup.getKeywordDelimiter(), newAutomaticKeywordGroup.getKeywordDelimiter())
+                    && Objects.equals(oldAutomaticKeywordGroup.getKeywordHierarchicalDelimiter(), newAutomaticKeywordGroup.getKeywordHierarchicalDelimiter())
+                    && Objects.equals(oldAutomaticKeywordGroup.getField().getName(), newAutomaticKeywordGroup.getField().getName());
+        } else if (oldGroup.getClass() == AutomaticPersonsGroup.class) {
+            AutomaticPersonsGroup oldAutomaticPersonsGroup = (AutomaticPersonsGroup) oldGroup;
+            AutomaticPersonsGroup newAutomaticPersonsGroup = (AutomaticPersonsGroup) newGroup;
+
+            return Objects.equals(oldAutomaticPersonsGroup.getField().getName(), newAutomaticPersonsGroup.getField().getName());
+        } else if (oldGroup.getClass() == TexGroup.class) {
+            TexGroup oldTexGroup = (TexGroup) oldGroup;
+            TexGroup newTexGroup = (TexGroup) newGroup;
+            return Objects.equals(oldTexGroup.getFilePath().toString(), newTexGroup.getFilePath().toString());
+        }
+        return true;
+    }
+
+    private boolean nameIsUnique(AbstractGroup oldGroup, AbstractGroup newGroup, BibDatabaseContext database) {
+        int groupsWithSameName = 0;
+        Optional<GroupTreeNode> databaseRootGroup = database.getMetaData().getGroups();
+        if (databaseRootGroup.isPresent()) {
+            // we need to check the old name for duplicates. If the new group name occurs more than once, it won't matter
+            groupsWithSameName = databaseRootGroup.get().findChildrenSatisfying(g -> g.getName().equals(oldGroup.getName())).size();
+        }
+        return groupsWithSameName < 2;
+    }
+
+    private Optional<ButtonType> showConfirmationPanel(boolean isNowWordKeywordGroup) {
+        String content = Localization.lang("Assign the original group's entries to this group?");
+        ButtonType keepAssignments = new ButtonType(Localization.lang("Assign"), ButtonBar.ButtonData.YES);
+        ButtonType removeAssignments = new ButtonType(Localization.lang("Do not assign"), ButtonBar.ButtonData.NO);
+        ButtonType cancel = new ButtonType(Localization.lang("Cancel"), ButtonBar.ButtonData.CANCEL_CLOSE);
+
+        if (isNowWordKeywordGroup) {
+            content = content + "\n\n" +
+                    Localization.lang("(Note: If original entries lack keywords to qualify for the new group configuration, confirming here will add them)");
+        }
+        return dialogService.showCustomButtonDialogAndWait(Alert.AlertType.WARNING,
+                Localization.lang("Change of Grouping Method"),
+                content,
+                keepAssignments,
+                removeAssignments,
+                cancel);
+    }
+}
diff --git a/src/main/java/org/jabref/gui/maintable/Selection.java b/src/main/java/org/jabref/gui/maintable/Selection.java
new file mode 100644
index 00000000000..c86ef29907d
--- /dev/null
+++ b/src/main/java/org/jabref/gui/maintable/Selection.java
@@ -0,0 +1,6 @@
+package org.jabref.gui.maintable;
+
+public enum Selection {
+    INCLUDE_SELECTED_ENTRIES,
+    IGNORE_SELECTED_ENTRIES
+}
diff --git a/src/main/java/org/jabref/gui/preferences/groups/GroupsTab.fxml b/src/main/java/org/jabref/gui/preferences/groups/GroupsTab.fxml
index dafe1478ab5..bb13f8b4afa 100644
--- a/src/main/java/org/jabref/gui/preferences/groups/GroupsTab.fxml
+++ b/src/main/java/org/jabref/gui/preferences/groups/GroupsTab.fxml
@@ -20,4 +20,6 @@
                  toggleGroup="$groupViewMode"/>
     <CheckBox fx:id="autoAssignGroup" text="%Automatically assign new entry to selected groups"/>
     <CheckBox fx:id="displayGroupCount" text="%Display count of items in group"/>
+    <CheckBox fx:id="autoIncludeSelected" text="%Automatically include selected entries when a new group is created"/>
+
 </fx:root>
diff --git a/src/main/java/org/jabref/gui/preferences/groups/GroupsTab.java b/src/main/java/org/jabref/gui/preferences/groups/GroupsTab.java
index 1bb3bb1f2bb..2e03e1dd682 100644
--- a/src/main/java/org/jabref/gui/preferences/groups/GroupsTab.java
+++ b/src/main/java/org/jabref/gui/preferences/groups/GroupsTab.java
@@ -16,6 +16,7 @@ public class GroupsTab extends AbstractPreferenceTabView<GroupsTabViewModel> imp
     @FXML private RadioButton groupViewModeUnion;
     @FXML private CheckBox autoAssignGroup;
     @FXML private CheckBox displayGroupCount;
+    @FXML private CheckBox autoIncludeSelected;
 
     public GroupsTab() {
         ViewLoader.view(this)
@@ -30,10 +31,10 @@ public String getTabName() {
 
     public void initialize() {
         this.viewModel = new GroupsTabViewModel(preferencesService.getGroupsPreferences());
-
         groupViewModeIntersection.selectedProperty().bindBidirectional(viewModel.groupViewModeIntersectionProperty());
         groupViewModeUnion.selectedProperty().bindBidirectional(viewModel.groupViewModeUnionProperty());
         autoAssignGroup.selectedProperty().bindBidirectional(viewModel.autoAssignGroupProperty());
         displayGroupCount.selectedProperty().bindBidirectional(viewModel.displayGroupCount());
+        autoIncludeSelected.selectedProperty().bindBidirectional(viewModel.autoIncludeSelectedEntriesProperty());
     }
 }
diff --git a/src/main/java/org/jabref/gui/preferences/groups/GroupsTabViewModel.java b/src/main/java/org/jabref/gui/preferences/groups/GroupsTabViewModel.java
index 84286ab62f3..5bfdc65c4cf 100644
--- a/src/main/java/org/jabref/gui/preferences/groups/GroupsTabViewModel.java
+++ b/src/main/java/org/jabref/gui/preferences/groups/GroupsTabViewModel.java
@@ -13,6 +13,7 @@ public class GroupsTabViewModel implements PreferenceTabViewModel {
     private final BooleanProperty groupViewModeUnionProperty = new SimpleBooleanProperty();
     private final BooleanProperty autoAssignGroupProperty = new SimpleBooleanProperty();
     private final BooleanProperty displayGroupCountProperty = new SimpleBooleanProperty();
+    private final BooleanProperty autoIncludeSelectedEntriesProperty = new SimpleBooleanProperty();
 
     private final GroupsPreferences groupsPreferences;
 
@@ -34,6 +35,7 @@ public void setValues() {
         }
         autoAssignGroupProperty.setValue(groupsPreferences.shouldAutoAssignGroup());
         displayGroupCountProperty.setValue(groupsPreferences.shouldDisplayGroupCount());
+        autoIncludeSelectedEntriesProperty.setValue(groupsPreferences.shouldAutoIncludeSelected());
     }
 
     @Override
@@ -41,6 +43,7 @@ public void storeSettings() {
         groupsPreferences.setGroupViewMode(groupViewModeIntersectionProperty.getValue() ? GroupViewMode.INTERSECTION : GroupViewMode.UNION);
         groupsPreferences.setAutoAssignGroup(autoAssignGroupProperty.getValue());
         groupsPreferences.setDisplayGroupCount(displayGroupCountProperty.getValue());
+        groupsPreferences.setAutoIncludeSelected(autoIncludeSelectedEntriesProperty.getValue());
     }
 
     public BooleanProperty groupViewModeIntersectionProperty() {
@@ -55,6 +58,10 @@ public BooleanProperty autoAssignGroupProperty() {
         return autoAssignGroupProperty;
     }
 
+    public BooleanProperty autoIncludeSelectedEntriesProperty() {
+        return autoIncludeSelectedEntriesProperty;
+    }
+
     public BooleanProperty displayGroupCount() {
         return displayGroupCountProperty;
     }
diff --git a/src/main/java/org/jabref/logic/database/DatabaseMerger.java b/src/main/java/org/jabref/logic/database/DatabaseMerger.java
index 013b2e141b6..1c0868439e9 100644
--- a/src/main/java/org/jabref/logic/database/DatabaseMerger.java
+++ b/src/main/java/org/jabref/logic/database/DatabaseMerger.java
@@ -105,11 +105,12 @@ public void mergeMetaData(MetaData target, MetaData other, String otherFilename,
     private void mergeGroups(MetaData target, MetaData other, String otherFilename, List<BibEntry> allOtherEntries) {
         // Adds the specified node as a child of the current root. The group contained in <b>newGroups</b> must not be of
         // type AllEntriesGroup, since every tree has exactly one AllEntriesGroup (its root). The <b>newGroups</b> are
-        // inserted directly, i.e. they are not deepCopy()'d.
-        other.getGroups().ifPresent(newGroups -> {
+        // deepCopy()'d by proxy through the GroupTreeNode's 'setGroup' function. This should allow 'undos'
+        // to be possible, if implemented.
+        other.getGroups().ifPresent(node -> {
             // ensure that there is always only one AllEntriesGroup in the resulting database
             // "Rename" the AllEntriesGroup of the imported database to "Imported"
-            if (newGroups.getGroup() instanceof AllEntriesGroup) {
+            if (node.getGroup() instanceof AllEntriesGroup) {
                 // create a dummy group
                 try {
                     // This will cause a bug if the group already exists
@@ -119,16 +120,16 @@ private void mergeGroups(MetaData target, MetaData other, String otherFilename,
                             "Imported " + newGroupName,
                             GroupHierarchyType.INDEPENDENT,
                             keywordDelimiter);
-                    newGroups.setGroup(group);
                     group.add(allOtherEntries);
+                    node.setGroup(group, true, false, allOtherEntries);
                 } catch (IllegalArgumentException e) {
                     LOGGER.error("Problem appending entries to group", e);
                 }
             }
             target.getGroups().ifPresentOrElse(
-                    newGroups::moveTo,
+                    node::moveTo,
                     // target does not contain any groups, so we can just use the new groups
-                    () -> target.setGroups(newGroups));
+                    () -> target.setGroups(node));
         });
     }
 
diff --git a/src/main/java/org/jabref/model/database/BibDatabaseContext.java b/src/main/java/org/jabref/model/database/BibDatabaseContext.java
index 8743c243749..3e2f8b37d14 100644
--- a/src/main/java/org/jabref/model/database/BibDatabaseContext.java
+++ b/src/main/java/org/jabref/model/database/BibDatabaseContext.java
@@ -9,6 +9,8 @@
 import java.util.Optional;
 import java.util.UUID;
 
+import javafx.collections.ObservableList;
+
 import org.jabref.architecture.AllowedToUseLogic;
 import org.jabref.gui.LibraryTab;
 import org.jabref.gui.desktop.JabRefDesktop;
@@ -249,7 +251,7 @@ public void convertToLocalDatabase() {
         this.location = DatabaseLocation.LOCAL;
     }
 
-    public List<BibEntry> getEntries() {
+    public ObservableList<BibEntry> getEntries() {
         return database.getEntries();
     }
 
diff --git a/src/main/java/org/jabref/model/groups/AbstractGroup.java b/src/main/java/org/jabref/model/groups/AbstractGroup.java
index 5f0aa7cbcfe..e2436c59ee8 100644
--- a/src/main/java/org/jabref/model/groups/AbstractGroup.java
+++ b/src/main/java/org/jabref/model/groups/AbstractGroup.java
@@ -4,6 +4,8 @@
 import java.util.Objects;
 import java.util.Optional;
 
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleIntegerProperty;
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.property.StringProperty;
 import javafx.scene.paint.Color;
@@ -29,6 +31,7 @@ public abstract class AbstractGroup implements SearchMatcher {
     protected boolean isExpanded = true;
     protected Optional<String> description = Optional.empty();
     protected Optional<String> iconName = Optional.empty();
+    protected IntegerProperty versionNumber = new SimpleIntegerProperty();
 
     protected AbstractGroup(String name, GroupHierarchyType context) {
         this.name.setValue(name);
@@ -40,10 +43,10 @@ public String toString() {
         return "AbstractGroup{" +
                 "name='" + name.getValue() + '\'' +
                 ", context=" + context +
-                ", color=" + color +
+                ", color=" + color.orElse(Color.BLACK) +
                 ", isExpanded=" + isExpanded +
-                ", description=" + description +
-                ", iconName=" + iconName +
+                ", description=" + description.orElse("null") +
+                ", iconName=" + iconName.orElse("null") +
                 '}';
     }
 
@@ -56,13 +59,14 @@ public boolean equals(Object other) {
             return false;
         }
         AbstractGroup that = (AbstractGroup) other;
-        return Objects.equals(this.name.getValue(), that.name.getValue()) && Objects.equals(this.description, that.description)
+        return Objects.equals(this.name.getValue(), that.name.getValue())
+                && Objects.equals(this.description, that.description)
                 && Objects.equals(this.context, that.context);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(name.getValue(), description, context);
+        return Objects.hash(name.getValue(), getDescription().orElse("null"), getHierarchicalContext());
     }
 
     public Optional<Color> getColor() {
@@ -75,7 +79,7 @@ public void setColor(Color color) {
 
     public void setColor(String colorString) {
         if (StringUtil.isBlank(colorString)) {
-            color = Optional.empty();
+            setColor((Color) null);
         } else {
             setColor(Color.valueOf(colorString));
         }
diff --git a/src/main/java/org/jabref/model/groups/AutomaticGroup.java b/src/main/java/org/jabref/model/groups/AutomaticGroup.java
index 026ce74f76f..f666b3ccffe 100644
--- a/src/main/java/org/jabref/model/groups/AutomaticGroup.java
+++ b/src/main/java/org/jabref/model/groups/AutomaticGroup.java
@@ -27,7 +27,7 @@ public boolean isDynamic() {
     public ObservableList<GroupTreeNode> createSubgroups(ObservableList<BibEntry> entries) {
         // TODO: Propagate changes to entry list (however: there is no flatMap and collect as TransformationList)
         return entries.stream()
-                      .flatMap(entry -> createSubgroups(entry).stream())
-                      .collect(TreeCollector.mergeIntoTree(GroupTreeNode::isSameGroupAs));
+              .flatMap(entry -> createSubgroups(entry).stream())
+              .collect(TreeCollector.mergeIntoTree(GroupTreeNode::isSameGroupAs));
     }
 }
diff --git a/src/main/java/org/jabref/model/groups/AutomaticKeywordGroup.java b/src/main/java/org/jabref/model/groups/AutomaticKeywordGroup.java
index 06dfcd983c1..8f848df71cb 100644
--- a/src/main/java/org/jabref/model/groups/AutomaticKeywordGroup.java
+++ b/src/main/java/org/jabref/model/groups/AutomaticKeywordGroup.java
@@ -49,8 +49,10 @@ public boolean equals(Object o) {
             return false;
         }
         AutomaticKeywordGroup that = (AutomaticKeywordGroup) o;
-        return Objects.equals(keywordDelimiter, that.keywordDelimiter) &&
-                Objects.equals(field, that.field);
+        return
+            super.equals(that)
+            && Objects.equals(keywordDelimiter, that.keywordDelimiter)
+            && Objects.equals(field, that.field);
     }
 
     @Override
@@ -62,9 +64,9 @@ public int hashCode() {
     public Set<GroupTreeNode> createSubgroups(BibEntry entry) {
         KeywordList keywordList = entry.getFieldAsKeywords(field, keywordDelimiter);
         return keywordList.stream()
-                          .filter(keyword -> StringUtil.isNotBlank(keyword.get()))
-                          .map(this::createGroup)
-                          .collect(Collectors.toSet());
+              .filter(keyword -> StringUtil.isNotBlank(keyword.get()))
+              .map(this::createGroup)
+              .collect(Collectors.toSet());
     }
 
     private GroupTreeNode createGroup(Keyword keywordChain) {
diff --git a/src/main/java/org/jabref/model/groups/GroupTreeNode.java b/src/main/java/org/jabref/model/groups/GroupTreeNode.java
index d5954181d9d..c6e9e1eb2ca 100644
--- a/src/main/java/org/jabref/model/groups/GroupTreeNode.java
+++ b/src/main/java/org/jabref/model/groups/GroupTreeNode.java
@@ -6,8 +6,15 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.util.Subscription;
+
 import org.jabref.model.FieldChange;
 import org.jabref.model.TreeNode;
 import org.jabref.model.database.BibDatabase;
@@ -22,7 +29,8 @@
 public class GroupTreeNode extends TreeNode<GroupTreeNode> {
 
     private static final String PATH_DELIMITER = " > ";
-    private AbstractGroup group;
+    private final ObjectProperty<AbstractGroup> group;
+    private final StringProperty groupName;
 
     /**
      * Creates this node and associates the specified group with it.
@@ -31,7 +39,8 @@ public class GroupTreeNode extends TreeNode<GroupTreeNode> {
      */
     public GroupTreeNode(AbstractGroup group) {
         super(GroupTreeNode.class);
-        setGroup(group, false, false, null);
+        this.group = new SimpleObjectProperty<>(Objects.requireNonNull(group));
+        this.groupName = new SimpleStringProperty(group.getName());
     }
 
     public static GroupTreeNode fromGroup(AbstractGroup group) {
@@ -44,18 +53,7 @@ public static GroupTreeNode fromGroup(AbstractGroup group) {
      * @return the group associated with this node
      */
     public AbstractGroup getGroup() {
-        return group;
-    }
-
-    /**
-     * Associates the specified group with this node.
-     *
-     * @param newGroup the new group (has to be non-null)
-     * @deprecated use {@link #setGroup(AbstractGroup, boolean, boolean, List)}} instead
-     */
-    @Deprecated
-    public void setGroup(AbstractGroup newGroup) {
-        this.group = Objects.requireNonNull(newGroup);
+        return group.get();
     }
 
     /**
@@ -68,10 +66,10 @@ public void setGroup(AbstractGroup newGroup) {
      */
     public List<FieldChange> setGroup(AbstractGroup newGroup, boolean shouldKeepPreviousAssignments,
                                       boolean shouldRemovePreviousAssignments, List<BibEntry> entriesInDatabase) {
+        Objects.requireNonNull(newGroup);
         AbstractGroup oldGroup = getGroup();
-        group = Objects.requireNonNull(newGroup);
-
         List<FieldChange> changes = new ArrayList<>();
+
         boolean shouldRemoveFromOldGroup = shouldRemovePreviousAssignments && (oldGroup instanceof GroupEntryChanger);
         boolean shouldAddToNewGroup = shouldKeepPreviousAssignments && (newGroup instanceof GroupEntryChanger);
         if (shouldAddToNewGroup || shouldRemoveFromOldGroup) {
@@ -87,6 +85,14 @@ public List<FieldChange> setGroup(AbstractGroup newGroup, boolean shouldKeepPrev
                 changes.addAll(entryChanger.add(entriesMatchedByOldGroup));
             }
         }
+
+        if (newGroup instanceof GroupEntryChanger changer) {
+            changes.addAll(changer.add(entriesInDatabase.stream().filter(newGroup::isMatch).toList()));
+        }
+
+        group.set(newGroup);
+        groupName.set(newGroup.getName());
+        notifyAboutDescendantChange(this);
         return changes;
     }
 
@@ -94,17 +100,17 @@ public List<FieldChange> setGroup(AbstractGroup newGroup, boolean shouldKeepPrev
      * Creates a {@link SearchMatcher} that matches entries of this group and that takes the hierarchical information into account. I.e., it finds elements contained in this nodes group, or the union of those elements in its own group and its children's groups (recursively), or the intersection of the elements in its own group and its parent's group (depending on the hierarchical settings stored in the involved groups)
      */
     public SearchMatcher getSearchMatcher() {
-        return getSearchMatcher(group.getHierarchicalContext());
+        return getSearchMatcher(group.get().getHierarchicalContext());
     }
 
     private SearchMatcher getSearchMatcher(GroupHierarchyType originalContext) {
-        final GroupHierarchyType context = group.getHierarchicalContext();
+        final GroupHierarchyType context = group.get().getHierarchicalContext();
         if (context == GroupHierarchyType.INDEPENDENT) {
-            return group;
+            return group.get();
         }
         MatcherSet searchRule = MatcherSets.build(
                 context == GroupHierarchyType.REFINING ? MatcherSets.MatcherType.AND : MatcherSets.MatcherType.OR);
-        searchRule.addRule(group);
+        searchRule.addRule(group.get());
         if ((context == GroupHierarchyType.INCLUDING) && (originalContext != GroupHierarchyType.REFINING)) {
             for (GroupTreeNode child : getChildren()) {
                 searchRule.addRule(child.getSearchMatcher(originalContext));
@@ -126,13 +132,15 @@ public boolean equals(Object o) {
             return false;
         }
         GroupTreeNode that = (GroupTreeNode) o;
-        return Objects.equals(group, that.group) &&
-                Objects.equals(getChildren(), that.getChildren());
+        return Objects.equals(group.get(), that.group.get()) &&
+                getChildren()
+                        .stream().map(GroupTreeNode::getGroup)
+                        .allMatch(v -> that.getChildren().stream().map(GroupTreeNode::getGroup).anyMatch(v::equals));
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(group);
+        return group.get().hashCode();
     }
 
     /**
@@ -140,18 +148,18 @@ public int hashCode() {
      *
      * @param entries    List of {@link BibEntry} to search for
      * @param requireAll Whether to return only groups that must contain all entries
-     * @return List of {@link GroupTreeNode} containing the matches. {@link AllEntriesGroup} is always contained}
+     * @return List of {@link GroupTreeNode} containing the matches. {@link AllEntriesGroup} is always contained.
      */
     public List<GroupTreeNode> getContainingGroups(List<BibEntry> entries, boolean requireAll) {
         List<GroupTreeNode> groups = new ArrayList<>();
 
         // Add myself if I contain the entries
         if (requireAll) {
-            if (this.group.containsAll(entries)) {
+            if (this.group.get().containsAll(entries)) {
                 groups.add(this);
             }
         } else {
-            if (this.group.containsAny(entries)) {
+            if (this.group.get().containsAny(entries)) {
                 groups.add(this);
             }
         }
@@ -197,7 +205,7 @@ public List<GroupTreeNode> getMatchingGroups(List<BibEntry> entries) {
     public List<BibEntry> getEntriesInGroup(List<BibEntry> entries) {
         List<BibEntry> result = new ArrayList<>();
         for (BibEntry entry : entries) {
-            if (this.group.contains(entry)) {
+            if (this.group.get().contains(entry)) {
                 result.add(entry);
             }
         }
@@ -210,7 +218,11 @@ public List<BibEntry> getEntriesInGroup(List<BibEntry> entries) {
      * @return String the name of the group
      */
     public String getName() {
-        return group.getName();
+        return group.get().getName();
+    }
+
+    public Subscription nameSubscription(Consumer<String> consumer) {
+        return this.groupName.subscribe(consumer);
     }
 
     public GroupTreeNode addSubgroup(AbstractGroup subgroup) {
@@ -221,7 +233,7 @@ public GroupTreeNode addSubgroup(AbstractGroup subgroup) {
 
     @Override
     public GroupTreeNode copyNode() {
-        return GroupTreeNode.fromGroup(group);
+        return GroupTreeNode.fromGroup(group.get());
     }
 
     /**
@@ -255,7 +267,7 @@ public boolean matches(BibEntry entry) {
     }
 
     /**
-     * Get the path from the root of the tree as a string (every group name is separated by {@link #PATH_DELIMITER}.
+     * Get the path from the root of the tree as a string every group name is separated by {@link #PATH_DELIMITER}.
      * <p>
      * The name of the root is not included.
      */
@@ -269,7 +281,7 @@ public String getPath() {
     @Override
     public String toString() {
         return "GroupTreeNode{" +
-                "group=" + group +
+                "group=" + group.get() +
                 '}';
     }
 
@@ -322,6 +334,6 @@ public List<FieldChange> removeEntriesFromGroup(List<BibEntry> entries) {
      * Returns true if the underlying groups of both {@link GroupTreeNode}s is the same.
      */
     public boolean isSameGroupAs(GroupTreeNode other) {
-        return Objects.equals(group, other.group);
+        return Objects.equals(group.get(), other.group.get());
     }
 }
diff --git a/src/main/java/org/jabref/model/groups/RegexKeywordGroup.java b/src/main/java/org/jabref/model/groups/RegexKeywordGroup.java
index dc603ffa8e5..29f372fe0f2 100644
--- a/src/main/java/org/jabref/model/groups/RegexKeywordGroup.java
+++ b/src/main/java/org/jabref/model/groups/RegexKeywordGroup.java
@@ -11,7 +11,7 @@
  * Matches entries if the content of a given field is matched by a regular expression.
  */
 public class RegexKeywordGroup extends KeywordGroup {
-    private Pattern pattern;
+    private final Pattern pattern;
 
     public RegexKeywordGroup(String name, GroupHierarchyType context, Field searchField,
                              String searchExpression, boolean caseSensitive) {
diff --git a/src/main/java/org/jabref/preferences/JabRefPreferences.java b/src/main/java/org/jabref/preferences/JabRefPreferences.java
index e47e007e812..b55dedf6b6f 100644
--- a/src/main/java/org/jabref/preferences/JabRefPreferences.java
+++ b/src/main/java/org/jabref/preferences/JabRefPreferences.java
@@ -233,6 +233,7 @@ public class JabRefPreferences implements PreferencesService {
     public static final String KEYWORD_SEPARATOR = "groupKeywordSeparator";
     public static final String AUTO_ASSIGN_GROUP = "autoAssignGroup";
     public static final String DISPLAY_GROUP_COUNT = "displayGroupCount";
+    public static final String AUTO_INCLUDE_SELECTED_ENTRIES = "autoIncludeSelectedEntries";
     public static final String EXTRA_FILE_COLUMNS = "extraFileColumns";
     public static final String OVERRIDE_DEFAULT_FONT_SIZE = "overrideDefaultFontSize";
     public static final String MAIN_FONT_SIZE = "mainFontSize";
@@ -697,6 +698,7 @@ private JabRefPreferences() {
         defaults.put(AUTOCOMPLETER_COMPLETE_FIELDS, "author;editor;title;journal;publisher;keywords;crossref;related;entryset");
         defaults.put(AUTO_ASSIGN_GROUP, Boolean.TRUE);
         defaults.put(DISPLAY_GROUP_COUNT, Boolean.TRUE);
+        defaults.put(AUTO_INCLUDE_SELECTED_ENTRIES, Boolean.FALSE);
         defaults.put(GROUP_INTERSECT_UNION_VIEW_MODE, GroupViewMode.INTERSECTION.name());
         defaults.put(DEFAULT_HIERARCHICAL_CONTEXT, GroupHierarchyType.INDEPENDENT.name());
         defaults.put(KEYWORD_SEPARATOR, ", ");
@@ -1428,11 +1430,13 @@ public GroupsPreferences getGroupsPreferences() {
                 GroupViewMode.valueOf(get(GROUP_INTERSECT_UNION_VIEW_MODE)),
                 getBoolean(AUTO_ASSIGN_GROUP),
                 getBoolean(DISPLAY_GROUP_COUNT),
+                getBoolean(AUTO_INCLUDE_SELECTED_ENTRIES),
                 GroupHierarchyType.valueOf(get(DEFAULT_HIERARCHICAL_CONTEXT))
         );
 
         EasyBind.listen(groupsPreferences.groupViewModeProperty(), (obs, oldValue, newValue) -> put(GROUP_INTERSECT_UNION_VIEW_MODE, newValue.name()));
         EasyBind.listen(groupsPreferences.autoAssignGroupProperty(), (obs, oldValue, newValue) -> putBoolean(AUTO_ASSIGN_GROUP, newValue));
+        EasyBind.listen(groupsPreferences.autoIncludeSelectedProperty(), (obs, oldValue, newValue) -> putBoolean(AUTO_INCLUDE_SELECTED_ENTRIES, newValue));
         EasyBind.listen(groupsPreferences.displayGroupCountProperty(), (obs, oldValue, newValue) -> putBoolean(DISPLAY_GROUP_COUNT, newValue));
         EasyBind.listen(groupsPreferences.defaultHierarchicalContextProperty(), (obs, oldValue, newValue) -> put(DEFAULT_HIERARCHICAL_CONTEXT, newValue.name()));
 
diff --git a/src/main/resources/l10n/JabRef_en.properties b/src/main/resources/l10n/JabRef_en.properties
index 9908c8aafae..02397f8822c 100644
--- a/src/main/resources/l10n/JabRef_en.properties
+++ b/src/main/resources/l10n/JabRef_en.properties
@@ -2650,6 +2650,9 @@ Note\:\ The\ study\ directory\ should\ be\ empty.=Note: The study directory shou
 Warning\:\ The\ selected\ directory\ is\ not\ empty.=Warning: The selected directory is not empty.
 Warning\:\ Failed\ to\ check\ if\ the\ directory\ is\ empty.=Warning: Failed to check if the directory is empty.
 Warning\:\ The\ selected\ directory\ is\ not\ a\ valid\ directory.=Warning: The selected directory is not a valid directory.
+Add\ subgroup\ from\ selection=Add subgroup from selection
+Automatically\ include\ selected\ entries\ when\ a\ new\ group\ is\ created=Automatically include selected entries when a new group is created
+Include\ selected\ entries\ in\ created\ subgroup=Include selected entries in created subgroup
 
 Currently\ selected\ JStyle\:\ '%0' = Currently selected JStyle: '%0'
 Currently\ selected\ CSL\ Style\:\ '%0' = Currently selected CSL Style: '%0'
diff --git a/src/test/java/org/jabref/gui/groups/GroupDialogViewModelTest.java b/src/test/java/org/jabref/gui/groups/GroupDialogViewModelTest.java
index 1c47527d0f8..8bd6f97d840 100644
--- a/src/test/java/org/jabref/gui/groups/GroupDialogViewModelTest.java
+++ b/src/test/java/org/jabref/gui/groups/GroupDialogViewModelTest.java
@@ -62,14 +62,14 @@ void validateExistingAbsolutePath() throws Exception {
         when(metaData.getLatexFileDirectory(any(String.class))).thenReturn(Optional.of(temporaryFolder));
 
         viewModel.texGroupFilePathProperty().setValue(anAuxFile.toString());
-        assertTrue(viewModel.texGroupFilePathValidatonStatus().isValid());
+        assertTrue(viewModel.texGroupFilePathValidationStatus().isValid());
     }
 
     @Test
     void validateNonExistingAbsolutePath() {
         var notAnAuxFile = temporaryFolder.resolve("notanauxfile.aux").toAbsolutePath();
         viewModel.texGroupFilePathProperty().setValue(notAnAuxFile.toString());
-        assertFalse(viewModel.texGroupFilePathValidatonStatus().isValid());
+        assertFalse(viewModel.texGroupFilePathValidationStatus().isValid());
     }
 
     @Test
@@ -81,7 +81,7 @@ void validateExistingRelativePath() throws Exception {
         when(metaData.getLatexFileDirectory(any(String.class))).thenReturn(Optional.of(temporaryFolder));
 
         viewModel.texGroupFilePathProperty().setValue(anAuxFile.toString());
-        assertTrue(viewModel.texGroupFilePathValidatonStatus().isValid());
+        assertTrue(viewModel.texGroupFilePathValidationStatus().isValid());
     }
 
     @Test
diff --git a/src/test/java/org/jabref/gui/groups/GroupNodeViewModelTest.java b/src/test/java/org/jabref/gui/groups/GroupNodeViewModelTest.java
index f05b398d285..ad62ed9e3b2 100644
--- a/src/test/java/org/jabref/gui/groups/GroupNodeViewModelTest.java
+++ b/src/test/java/org/jabref/gui/groups/GroupNodeViewModelTest.java
@@ -40,7 +40,9 @@ class GroupNodeViewModelTest {
     @BeforeEach
     void setUp() {
         stateManager = mock(StateManager.class);
+        StateManager templateStateManager = new StateManager();
         when(stateManager.getSelectedEntries()).thenReturn(FXCollections.emptyObservableList());
+        when(stateManager.activeGroupProperty()).thenReturn(templateStateManager.activeGroupProperty());
         databaseContext = new BibDatabaseContext();
         taskExecutor = new CurrentThreadTaskExecutor();
         preferencesService = mock(PreferencesService.class);
@@ -48,6 +50,7 @@ void setUp() {
                 GroupViewMode.UNION,
                 true,
                 true,
+                false,
                 GroupHierarchyType.INDEPENDENT
         ));
 
@@ -96,9 +99,9 @@ void treeOfAutomaticKeywordGroupIsCombined() {
         expectedA.addSubgroup(expectedGroupC);
         expectedA.addSubgroup(expectedGroupD);
         GroupNodeViewModel expectedE = getViewModelForGroup(expectedGroupE);
-        ObservableList<GroupNodeViewModel> expected = FXCollections.observableArrayList(expectedA, expectedE);
+        ObservableList<GroupTreeNode> expected = FXCollections.observableArrayList(expectedA.getGroupNode(), expectedE.getGroupNode());
 
-        assertEquals(expected, groupViewModel.getChildren());
+        assertEquals(expected, groupViewModel.getGroupNode().getChildren());
     }
 
     @Test
diff --git a/src/test/java/org/jabref/gui/groups/GroupTreeViewModelTest.java b/src/test/java/org/jabref/gui/groups/GroupTreeViewModelTest.java
index bdb27ee2fc1..bb6589ae45a 100644
--- a/src/test/java/org/jabref/gui/groups/GroupTreeViewModelTest.java
+++ b/src/test/java/org/jabref/gui/groups/GroupTreeViewModelTest.java
@@ -4,6 +4,7 @@
 
 import org.jabref.gui.DialogService;
 import org.jabref.gui.StateManager;
+import org.jabref.gui.maintable.CreateGroupAction;
 import org.jabref.gui.util.CurrentThreadTaskExecutor;
 import org.jabref.gui.util.CustomLocalDragboard;
 import org.jabref.gui.util.TaskExecutor;
@@ -40,7 +41,7 @@ class GroupTreeViewModelTest {
     void setUp() {
         databaseContext = new BibDatabaseContext();
         stateManager = new StateManager();
-        stateManager.activeDatabaseProperty().setValue(Optional.of(databaseContext));
+        stateManager.setActiveDatabase(databaseContext);
         taskExecutor = new CurrentThreadTaskExecutor();
         preferencesService = mock(PreferencesService.class);
         dialogService = mock(DialogService.class, Answers.RETURNS_DEEP_STUBS);
@@ -49,6 +50,7 @@ void setUp() {
                 GroupViewMode.UNION,
                 true,
                 true,
+                false,
                 GroupHierarchyType.INDEPENDENT));
         groupTree = new GroupTreeViewModel(stateManager, mock(DialogService.class), preferencesService, taskExecutor, new CustomLocalDragboard());
     }
@@ -56,12 +58,12 @@ void setUp() {
     @Test
     void rootGroupIsAllEntriesByDefault() {
         AllEntriesGroup allEntriesGroup = new AllEntriesGroup("All entries");
-        assertEquals(new GroupNodeViewModel(databaseContext, stateManager, taskExecutor, allEntriesGroup, new CustomLocalDragboard(), preferencesService), groupTree.rootGroupProperty().getValue());
+        assertEquals(new GroupNodeViewModel(databaseContext, stateManager, taskExecutor, allEntriesGroup, new CustomLocalDragboard(), preferencesService).getGroupNode(), groupTree.rootGroup().getGroupNode());
     }
 
     @Test
     void rootGroupIsSelectedByDefault() {
-        assertEquals(groupTree.rootGroupProperty().get().getGroupNode(), stateManager.getSelectedGroups(databaseContext).getFirst());
+        assertEquals(groupTree.rootGroup().getGroupNode(), stateManager.getSelectedGroups(databaseContext).getFirst());
     }
 
     @Test
@@ -72,7 +74,7 @@ void explicitGroupsAreRemovedFromEntriesOnDelete() {
 
         GroupNodeViewModel model = new GroupNodeViewModel(databaseContext, stateManager, taskExecutor, group, new CustomLocalDragboard(), preferencesService);
         model.addEntriesToGroup(databaseContext.getEntries());
-        groupTree.removeGroupsAndSubGroupsFromEntries(model);
+        groupTree.removeGroupsAndSubGroupsFromEntries(model.getGroupNode());
 
         assertEquals(Optional.empty(), entry.getField(StandardField.GROUPS));
     }
@@ -86,7 +88,7 @@ void keywordGroupsAreNotRemovedFromEntriesOnDelete() {
 
         GroupNodeViewModel model = new GroupNodeViewModel(databaseContext, stateManager, taskExecutor, group, new CustomLocalDragboard(), preferencesService);
         model.addEntriesToGroup(databaseContext.getEntries());
-        groupTree.removeGroupsAndSubGroupsFromEntries(model);
+        groupTree.removeGroupsAndSubGroupsFromEntries(model.getGroupNode());
 
         assertEquals(groupName, entry.getField(StandardField.KEYWORDS).get());
     }
@@ -97,9 +99,7 @@ void shouldNotShowDialogWhenGroupNameChanges() {
         AbstractGroup newGroup = new ExplicitGroup("newGroupName", GroupHierarchyType.INDEPENDENT, ',');
         BibEntry entry = new BibEntry();
         databaseContext.getDatabase().insertEntry(entry);
-
-        GroupTreeViewModel model = new GroupTreeViewModel(stateManager, dialogService, preferencesService, taskExecutor, new CustomLocalDragboard());
-        assertTrue(model.onlyMinorChanges(oldGroup, newGroup));
+        assertTrue(CreateGroupAction.changesAreMinor(oldGroup, newGroup));
     }
 
     @Test
@@ -109,9 +109,7 @@ void shouldNotShowDialogWhenGroupsAreEqual() {
 
         BibEntry entry = new BibEntry();
         databaseContext.getDatabase().insertEntry(entry);
-
-        GroupTreeViewModel model = new GroupTreeViewModel(stateManager, dialogService, preferencesService, taskExecutor, new CustomLocalDragboard());
-        assertTrue(model.onlyMinorChanges(oldGroup, newGroup));
+        assertTrue(CreateGroupAction.changesAreMinor(oldGroup, newGroup));
     }
 
     @Test
@@ -122,8 +120,7 @@ void shouldShowDialogWhenKeywordDiffers() {
         BibEntry entry = new BibEntry();
         databaseContext.getDatabase().insertEntry(entry);
 
-        GroupTreeViewModel model = new GroupTreeViewModel(stateManager, dialogService, preferencesService, taskExecutor, new CustomLocalDragboard());
-        assertFalse(model.onlyMinorChanges(oldGroup, newGroup));
+        assertFalse(CreateGroupAction.changesAreMinor(oldGroup, newGroup));
     }
 
     @Test
@@ -133,8 +130,6 @@ void shouldShowDialogWhenCaseSensitivyDiffers() {
 
         BibEntry entry = new BibEntry();
         databaseContext.getDatabase().insertEntry(entry);
-
-        GroupTreeViewModel model = new GroupTreeViewModel(stateManager, dialogService, preferencesService, taskExecutor, new CustomLocalDragboard());
-        assertFalse(model.onlyMinorChanges(oldGroup, newGroup));
+        assertFalse(CreateGroupAction.changesAreMinor(oldGroup, newGroup));
     }
 }
diff --git a/src/test/java/org/jabref/model/groups/AutomaticKeywordGroupTest.java b/src/test/java/org/jabref/model/groups/AutomaticKeywordGroupTest.java
index a6a84698ff2..5c3e036d79e 100644
--- a/src/test/java/org/jabref/model/groups/AutomaticKeywordGroupTest.java
+++ b/src/test/java/org/jabref/model/groups/AutomaticKeywordGroupTest.java
@@ -2,6 +2,7 @@
 
 import java.util.HashSet;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.jabref.model.entry.BibEntry;
 import org.jabref.model.entry.field.StandardField;
@@ -9,6 +10,7 @@
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class AutomaticKeywordGroupTest {
 
@@ -19,7 +21,10 @@ void createSubgroupsForTwoKeywords() throws Exception {
 
         Set<GroupTreeNode> expected = createIncludingKeywordsSubgroup();
 
-        assertEquals(expected, keywordsGroup.createSubgroups(entry));
+        assertEquals(
+                expected.stream().map(GroupTreeNode::getGroup).collect(Collectors.toSet()),
+                keywordsGroup.createSubgroups(entry).stream().map(GroupTreeNode::getGroup).collect(Collectors.toSet())
+        );
     }
 
     @Test
@@ -28,8 +33,10 @@ void createSubgroupsIgnoresEmptyKeyword() throws Exception {
         BibEntry entry = new BibEntry().withField(StandardField.KEYWORDS, "A, ,B");
 
         Set<GroupTreeNode> expected = createIncludingKeywordsSubgroup();
+        Set<GroupTreeNode> actual = keywordsGroup.createSubgroups(entry);
 
-        assertEquals(expected, keywordsGroup.createSubgroups(entry));
+        assertEquals(actual, expected);
+        assertTrue(actual.containsAll(expected));
     }
 
     private Set<GroupTreeNode> createIncludingKeywordsSubgroup() {