diff --git a/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/JdtTextTestSuite.java b/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/JdtTextTestSuite.java
index ae6b859828e..c59e7208361 100644
--- a/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/JdtTextTestSuite.java
+++ b/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/JdtTextTestSuite.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2024 IBM Corporation and others.
+ * Copyright (c) 2000, 2025 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -20,7 +20,7 @@
 import org.eclipse.jdt.text.tests.codemining.CodeMiningTriggerTest;
 import org.eclipse.jdt.text.tests.codemining.ParameterNamesCodeMiningTest;
 import org.eclipse.jdt.text.tests.contentassist.ContentAssistTestSuite;
-import org.eclipse.jdt.text.tests.folding.FoldingTest;
+import org.eclipse.jdt.text.tests.folding.FoldingTestSuite;
 import org.eclipse.jdt.text.tests.semantictokens.SemanticTokensProviderTest;
 import org.eclipse.jdt.text.tests.spelling.SpellCheckEngineTestCase;
 import org.eclipse.jdt.text.tests.templates.TemplatesTestSuite;
@@ -71,7 +71,7 @@
 	JavaElementPrefixPatternMatcherTest.class,
 	CodeMiningTriggerTest.class,
 	ParameterNamesCodeMiningTest.class,
-	FoldingTest.class,
+	FoldingTestSuite.class,
 })
 public class JdtTextTestSuite {
 }
\ No newline at end of file
diff --git a/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/folding/CustomFoldingRegionTest.java b/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/folding/CustomFoldingRegionTest.java
new file mode 100644
index 00000000000..2a2e287dfdd
--- /dev/null
+++ b/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/folding/CustomFoldingRegionTest.java
@@ -0,0 +1,435 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Daniel Schmid and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Daniel Schmid - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.text.tests.folding;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import org.eclipse.jdt.testplugin.JavaProjectHelper;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.jface.preference.IPreferenceStore;
+
+import org.eclipse.jface.text.IRegion;
+
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+
+import org.eclipse.jdt.ui.PreferenceConstants;
+import org.eclipse.jdt.ui.tests.core.rules.ProjectTestSetup;
+
+import org.eclipse.jdt.internal.ui.JavaPlugin;
+
+public class CustomFoldingRegionTest {
+	@Rule
+	public ProjectTestSetup projectSetup= new ProjectTestSetup();
+
+	private IJavaProject fJProject1;
+
+	private IPackageFragmentRoot fSourceFolder;
+
+	private IPackageFragment fPackageFragment;
+
+	@Before
+	public void setUp() throws CoreException {
+		fJProject1= projectSetup.getProject();
+		fSourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
+		fPackageFragment= fSourceFolder.createPackageFragment("org.example.test", false, null);
+	}
+
+
+	@After
+	public void tearDown() throws CoreException {
+		JavaProjectHelper.delete(fJProject1);
+		IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
+		store.setToDefault(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_START);
+		store.setToDefault(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_END);
+	}
+
+	@Test
+	public void testNoCustomFoldingRegions() throws Exception {
+		String str= """
+				package org.example.test;
+				public class Test {
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(0, projectionRanges.size());
+	}
+
+	@Test
+	public void testCustomFoldingRegionInsideAndOutsideClass() throws Exception {
+		String str= """
+				package org.example.test;
+				// #region
+				// something else
+				// #endregion
+				public class Test {
+					// #region
+					// something else
+					// #endregion
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(2, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 1, 3);
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 5, 7);
+	}
+
+	@Test
+	public void testNestedCustomRegions() throws Exception {
+		String str= """
+				package org.example.test;
+
+				public class Test {
+					// #region outer
+					// #region inner
+
+					// #endregion outer
+					// #endregion inner
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(2, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 3, 7);//outer
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 4, 6);//inner
+	}
+
+	@Test
+	public void testNoCustomFoldingRegionsInMethod() throws Exception {
+		String str= """
+				package org.example.test;
+				public class Test {
+					void a(){
+
+					}
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(1, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 2, 3);
+	}
+
+	@Test
+	public void testCustomFoldingRegionsInMethod() throws Exception {
+		String str= """
+				package org.example.test;
+				public class Test {
+					void a(){
+						// #region
+
+						// #endregion
+					}
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(2, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 2, 6);
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 3, 5);
+	}
+
+	@Test
+	public void testNoCustomFoldingRegionsSingleImport() throws Exception {
+		String str= """
+				package org.example.test;
+
+				import java.util.List;
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(0, projectionRanges.size());
+	}
+
+	@Test
+	public void testCustomFoldingRegionAroundSingleImport() throws Exception {
+		String str= """
+				package org.example.test;
+
+				// #region imports
+				import java.util.List;
+				// #endregion
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(1, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 2, 4);
+	}
+
+	@Test
+	public void testCustomFoldingRegionAroundClasses() throws Exception {
+		String str= """
+				package org.example.test;
+
+				class A {
+
+				}
+
+				// #region
+
+				class B {
+
+				}
+
+				class C {
+
+				}
+				// #endregion
+
+				class D {
+
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(1, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 6, 15);
+	}
+
+	@Test
+	public void testCustomFoldingRegionsMultipleLevels() throws Exception {
+		String str= """
+				package org.example.test;
+				// #region outside class
+				public class Test {
+					// #endregion should be ignored
+					// #region outside method
+					void a(){
+						// #endregion should be ignored
+						// #region inside method
+						System.out.println("Hello World");
+						// #endregion inside method
+					}
+					// #endregion outside method
+				}
+				// #endregion outside class
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(4, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 1, 13);//outside class
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 4, 11);//outside method
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 5, 10);//void a()
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 7, 9);//inside method
+	}
+
+	@Test
+	public void testCustomFoldingRegionsNotEndingTooEarly() throws Exception {
+		String str= """
+				package org.example.test;
+
+				public class Test {
+					void a(){
+						// #region inside method
+					}
+					// #endregion outside method
+				}
+				// #endregion outside class
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(1, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 3, 4);//void a()
+	}
+
+	@Test
+	public void testCustomFoldingRegionsUsingSpecialCommentTypes() throws Exception {
+		String str= """
+				package org.example.test;
+
+				public class Test {
+					void a(){
+						/* #region multiline
+						*/
+						/** #region javadoc */
+						/** #endregion javadoc */
+						/* #endregion multiline
+						*/
+					}
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(3, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 3, 10);//void a()
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 4, 8);// multiline
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 6, 7);// javadoc
+	}
+
+	@Test
+	public void testCustomRegionsWithLocalClass() throws Exception {
+		String str= """
+				package org.example.test;
+
+				public class Test {
+					void a(){
+						// #region
+						int i;
+
+						// #endregion
+						class Inner{
+
+						}
+					}
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(3, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 3, 10);//void a()
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 4, 7);//region
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 8, 10);//class Inner
+	}
+
+	@Test
+	public void testNoCustomRegionAtDifferentLevelsWithOtherClass() throws Exception {
+		String str= """
+				package org.example.test;
+
+				public class Test{
+					// #region outside
+					public class A {
+						public void helloWorld() {
+
+						}
+						// #endregion inside
+					}
+
+					public class B {
+
+
+				    }
+
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(3, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 4, 8);//class A
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 5, 6);//void helloWorld()
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 11, 13);//class B
+	}
+
+	@Test
+	public void testCustomRegionsAroundFieldAndMethod() throws Exception {
+		String str= """
+				package org.example.test;
+
+				public class Test {
+					// #region
+					int a;
+
+					void b(){
+
+					}
+					// #endregion
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(2, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 3, 9);//region
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 6, 8);//void b()
+	}
+
+	@Test
+	public void testDifferentConfiguration() throws Exception {
+		IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
+		store.setValue(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_START, "#regstart");
+		store.setValue(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_END, "#regend");
+
+
+		String str= """
+				package org.example.test;
+				public class Test {
+					// #region should be ignored
+					// #regstart this is the region
+					// #regend should end here
+					// #endregion should be ignored
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(1, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 3, 4);
+	}
+
+	@Test
+	public void testCommentsInEmptyBlocks() throws Exception {
+		String str= """
+				package org.example.test;
+				public class Test {
+					void a(){
+						{/* #region 1*/}
+						System.out.println("Hello World");
+						{/* #endregion 1*/}
+					}
+				}
+				""";
+		List<IRegion> projectionRanges= getProjectionRangesOfFile(str);
+		assertEquals(2, projectionRanges.size());
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 2, 6);//void a()
+		assertContainsRegionUsingStartAndEndLine(projectionRanges, str, 3, 5);//region 1
+	}
+
+	private void assertContainsRegionUsingStartAndEndLine(List<IRegion> projectionRanges, String input, int startLine, int endLine) {
+		assertTrue(startLine <= endLine, "start line must be smaller or equal to end line");
+		int startLineBegin= findLineStartIndex(input, startLine);
+
+		int endLineBegin= findLineStartIndex(input, endLine);
+		int endLineEnd= findNextLineStart(input, endLineBegin);
+		endLineEnd= getLengthIfNotFound(input, endLineEnd);
+
+		for (IRegion region : projectionRanges) {
+			if (region.getOffset() == startLineBegin + 1 && region.getOffset() + region.getLength() == endLineEnd + 1) {
+				return;
+			}
+		}
+
+		fail(
+				"missing region from line " + startLine + " (index " + (startLineBegin + 1) + ") " +
+						"to line " + endLine + " (index " + (endLineEnd + 1) + ")" +
+						", actual regions: " + projectionRanges
+		);
+	}
+
+
+	private int getLengthIfNotFound(String input, int startLineEnd) {
+		if (startLineEnd == -1) {
+			startLineEnd= input.length();
+		}
+		return startLineEnd;
+	}
+
+
+	private int findLineStartIndex(String input, int lineNumber) {
+		int currentInputIndex= 0;
+		for (int i= 0; i < lineNumber; i++) {
+			currentInputIndex= findNextLineStart(input, currentInputIndex);
+			if (currentInputIndex == -1) {
+				fail("line number is greater than the total number of lines");
+			}
+		}
+		return currentInputIndex;
+	}
+
+
+	private int findNextLineStart(String input, int currentInputIndex) {
+		return input.indexOf('\n', currentInputIndex + 1);
+	}
+
+	private List<IRegion> getProjectionRangesOfFile(String str) throws Exception {
+		return FoldingTestUtils.getProjectionRangesOfFile(fPackageFragment, "Test.java", str);
+	}
+
+}
diff --git a/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/folding/FoldingTestSuite.java b/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/folding/FoldingTestSuite.java
new file mode 100644
index 00000000000..cdeb7598bdf
--- /dev/null
+++ b/org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/folding/FoldingTestSuite.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Daniel Schmid and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Daniel Schmid - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.text.tests.folding;
+
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
+
+@Suite
+@SelectClasses({
+	FoldingTest.class,
+	CustomFoldingRegionTest.class,
+})
+public class FoldingTestSuite {
+}
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/DefaultJavaFoldingPreferenceBlock.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/DefaultJavaFoldingPreferenceBlock.java
index 43510a919e0..10325997bb6 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/DefaultJavaFoldingPreferenceBlock.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/DefaultJavaFoldingPreferenceBlock.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * Copyright (c) 2000, 2025 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -15,10 +15,10 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.Map;
 
 import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyListener;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.layout.GridData;
@@ -28,6 +28,7 @@
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Group;
 import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
 
 import org.eclipse.jface.preference.IPreferenceStore;
 
@@ -60,6 +61,12 @@ public void widgetSelected(SelectionEvent e) {
 			fOverlayStore.setValue(fCheckBoxes.get(button), button.getSelection());
 		}
 	};
+	private Map<Text, String> fStringInputs= new HashMap<>();
+	private ModifyListener fModifyListener = e -> {
+		Text text = (Text)e.widget;
+		fOverlayStore.setValue(fStringInputs.get(text), text.getText());
+	};
+
 
 
 	public DefaultJavaFoldingPreferenceBlock() {
@@ -77,6 +84,9 @@ private OverlayKey[] createKeys() {
 		overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_FOLDING_IMPORTS));
 		overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_FOLDING_HEADERS));
 		overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_NEW_FOLDING_ENABLED));
+		overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGIONS));
+		overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_START));
+		overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_END));
 		return overlayKeys.toArray(new OverlayKey[overlayKeys.size()]);
 	}
 
@@ -88,32 +98,29 @@ public Control createControl(Composite composite) {
 		fOverlayStore.load();
 		fOverlayStore.start();
 
-		composite.setLayout(new GridLayout(1, false));
-		composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
-
-		Composite inner= new Composite(composite, SWT.NONE);
 		GridLayout layout= new GridLayout(1, false);
-		layout.verticalSpacing= 10;
+		layout.verticalSpacing= 3;
 		layout.marginWidth= 0;
-		layout.marginHeight= 0;
-		inner.setLayout(layout);
-		inner.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
-
-		Group initialFoldGroup = new Group(inner, SWT.NONE);
-		GridLayout initialFoldLayout = new GridLayout(1, false);
-		initialFoldLayout.marginWidth = 10;
-		initialFoldLayout.marginHeight = 10;
-		initialFoldGroup.setLayout(initialFoldLayout);
-		initialFoldGroup.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
-		initialFoldGroup.setText(FoldingMessages.DefaultJavaFoldingPreferenceBlock_title);
-
-		addCheckBox(initialFoldGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_comments, PreferenceConstants.EDITOR_FOLDING_JAVADOC, 0);
-		addCheckBox(initialFoldGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_headers, PreferenceConstants.EDITOR_FOLDING_HEADERS, 0);
-		addCheckBox(initialFoldGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_innerTypes, PreferenceConstants.EDITOR_FOLDING_INNERTYPES, 0);
-		addCheckBox(initialFoldGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_methods, PreferenceConstants.EDITOR_FOLDING_METHODS, 0);
-		addCheckBox(initialFoldGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_imports, PreferenceConstants.EDITOR_FOLDING_IMPORTS, 0);
-
-		Group extendedFoldingGroup= new Group(inner, SWT.NONE);
+//		layout.marginHeight= 0;
+		composite.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
+
+		Composite outer= new Composite(composite, SWT.NONE);
+		outer.setLayout(layout);
+		outer.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+
+		Group initialFoldingGroup= new Group(outer, SWT.NONE);
+		initialFoldingGroup.setLayout(layout);
+		initialFoldingGroup.setText(FoldingMessages.DefaultJavaFoldingPreferenceBlock_title);
+		initialFoldingGroup.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+
+		addCheckBox(initialFoldingGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_comments, PreferenceConstants.EDITOR_FOLDING_JAVADOC, 0);
+		addCheckBox(initialFoldingGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_headers, PreferenceConstants.EDITOR_FOLDING_HEADERS, 0);
+		addCheckBox(initialFoldingGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_innerTypes, PreferenceConstants.EDITOR_FOLDING_INNERTYPES, 0);
+		addCheckBox(initialFoldingGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_methods, PreferenceConstants.EDITOR_FOLDING_METHODS, 0);
+		addCheckBox(initialFoldingGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_imports, PreferenceConstants.EDITOR_FOLDING_IMPORTS, 0);
+		addCheckBox(initialFoldingGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_customRegions, PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGIONS, 0);
+
+		Group extendedFoldingGroup= new Group(outer, SWT.NONE);
 		GridLayout extendedFoldingLayout= new GridLayout(1, false);
 		extendedFoldingLayout.marginWidth= 10;
 		extendedFoldingLayout.marginHeight= 10;
@@ -126,7 +133,17 @@ public Control createControl(Composite composite) {
 		label.setLayoutData(gd);
 		label.setText(FoldingMessages.DefaultJavaFoldingPreferenceBlock_Warning_New_Feature);
 		addCheckBox(extendedFoldingGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_New, PreferenceConstants.EDITOR_NEW_FOLDING_ENABLED, 0);
-		return inner;
+
+		Group customRegionGroup= new Group(outer, SWT.NONE);
+		customRegionGroup.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+
+		GridLayout customRegionLayout= new GridLayout(2, false);
+		customRegionGroup.setLayout(customRegionLayout);
+		customRegionGroup.setText(FoldingMessages.DefaultJavaFoldingPreferenceBlock_custom_region_title);
+		addStringInput(customRegionGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_CustomRegionStart, PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_START);
+		addStringInput(customRegionGroup, FoldingMessages.DefaultJavaFoldingPreferenceBlock_CustomRegionEnd, PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_END);
+
+		return outer;
 	}
 
 	private Button addCheckBox(Composite parent, String label, String key, int indentation) {
@@ -145,13 +162,29 @@ private Button addCheckBox(Composite parent, String label, String key, int inden
 		return checkBox;
 	}
 
+	private void addStringInput(Composite parent, String label, String key) {
+		Label labelElement = new Label(parent, SWT.LEFT);
+		labelElement.setText(label);
+		GridData labelGridData= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
+		labelGridData.horizontalSpan= 1;
+		labelGridData.grabExcessVerticalSpace= false;
+		labelElement.setLayoutData(labelGridData);
+
+		Text textInput = new Text(parent, SWT.SINGLE | SWT.BORDER);
+		textInput.setText(label);
+		textInput.addModifyListener(fModifyListener);
+
+		GridData textGridData= new GridData(SWT.FILL, SWT.BEGINNING, true, false);
+		textGridData.horizontalSpan= 1;
+		textGridData.grabExcessVerticalSpace= true;
+		textInput.setLayoutData(textGridData);
+
+		fStringInputs.put(textInput, key);
+	}
+
 	private void initializeFields() {
-		Iterator<Button> it= fCheckBoxes.keySet().iterator();
-		while (it.hasNext()) {
-			Button b= it.next();
-			String key= fCheckBoxes.get(b);
-			b.setSelection(fOverlayStore.getBoolean(key));
-		}
+		fCheckBoxes.forEach((b, key) -> b.setSelection(fOverlayStore.getBoolean(key)));
+		fStringInputs.forEach((text, key) -> text.setText(fOverlayStore.getString(key)));
 	}
 
 	/*
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/FoldingMessages.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/FoldingMessages.java
index 12483f4b345..a3c7fc254a2 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/FoldingMessages.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/FoldingMessages.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2007 IBM Corporation and others.
+ * Copyright (c) 2000, 2025 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -33,6 +33,11 @@ private FoldingMessages() {
 	public static String DefaultJavaFoldingPreferenceBlock_imports;
 	public static String DefaultJavaFoldingPreferenceBlock_New;
 	public static String DefaultJavaFoldingPreferenceBlock_headers;
+	public static String DefaultJavaFoldingPreferenceBlock_customRegions;
+
+	public static String DefaultJavaFoldingPreferenceBlock_custom_region_title;
+	public static String DefaultJavaFoldingPreferenceBlock_CustomRegionStart;
+	public static String DefaultJavaFoldingPreferenceBlock_CustomRegionEnd;
 	public static String EmptyJavaFoldingPreferenceBlock_emptyCaption;
 	public static String JavaFoldingStructureProviderRegistry_warning_providerNotFound_resetToDefault;
 	public static String DefaultJavaFoldingPreferenceBlock_New_Setting_Title;
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/FoldingMessages.properties b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/FoldingMessages.properties
index f12af7f490e..651afe4b6ab 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/FoldingMessages.properties
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/folding/FoldingMessages.properties
@@ -1,5 +1,5 @@
 ###############################################################################
-# Copyright (c) 2000, 2006 IBM Corporation and others.
+# Copyright (c) 2000, 2025 IBM Corporation and others.
 #
 # This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License 2.0
@@ -19,6 +19,12 @@ DefaultJavaFoldingPreferenceBlock_innerTypes= Inner &types
 DefaultJavaFoldingPreferenceBlock_methods= &Members
 DefaultJavaFoldingPreferenceBlock_imports= &Imports
 DefaultJavaFoldingPreferenceBlock_headers= &Header Comments
+DefaultJavaFoldingPreferenceBlock_customRegions= Custom folding regions
+
+DefaultJavaFoldingPreferenceBlock_custom_region_title= Custom folding regions
+DefaultJavaFoldingPreferenceBlock_CustomRegionStart= Text marking start of region
+DefaultJavaFoldingPreferenceBlock_CustomRegionEnd= Text marking end of region
+
 DefaultJavaFoldingPreferenceBlock_New = &Activate feature
 DefaultJavaFoldingPreferenceBlock_New_Setting_Title = &Extended folding (Experimental)
 JavaFoldingStructureProviderRegistry_warning_providerNotFound_resetToDefault= The ''{0}'' folding provider could not be found. Resetting to the default folding provider.
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/PreferenceConstants.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/PreferenceConstants.java
index 51760a8ffc6..b115811c1b3 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/PreferenceConstants.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/PreferenceConstants.java
@@ -3482,6 +3482,36 @@ private PreferenceConstants() {
 	 */
 	public static final String EDITOR_FOLDING_HEADERS= "editor_folding_default_headers"; //$NON-NLS-1$
 
+	/**
+	 * A named preference that stores the value for custom region folding for the default folding provider.
+	 * <p>
+	 * Value is of type <code>Boolean</code>.
+	 * </p>
+	 *
+	 * @since 3.34
+	 */
+	public static final String EDITOR_FOLDING_CUSTOM_REGIONS= "editor_folding_custom_regions"; //$NON-NLS-1$
+
+	/**
+	 * A named preference that stores the value for the start indicator of custom folding regions for the default folding provider.
+	 * <p>
+	 * Value is of type <code>String</code>.
+	 * </p>
+	 *
+	 * @since 3.34
+	 */
+	public static final String EDITOR_FOLDING_CUSTOM_REGION_START= "editor_folding_custom_region_start"; //$NON-NLS-1$
+
+	/**
+	 * A named preference that stores the value for the end indicator of custom folding regions for the default folding provider.
+	 * <p>
+	 * Value is of type <code>String</code>.
+	 * </p>
+	 *
+	 * @since 3.34
+	 */
+	public static final String EDITOR_FOLDING_CUSTOM_REGION_END= "editor_folding_custom_region_end"; //$NON-NLS-1$
+
 	/**
 	 * A named preference that holds the methods or types whose methods are by default expanded with
 	 * constructors in the Call Hierarchy.
@@ -4310,6 +4340,9 @@ public static void initializeDefaultValues(IPreferenceStore store) {
 		store.setDefault(PreferenceConstants.EDITOR_FOLDING_METHODS, false);
 		store.setDefault(PreferenceConstants.EDITOR_FOLDING_IMPORTS, true);
 		store.setDefault(PreferenceConstants.EDITOR_FOLDING_HEADERS, true);
+		store.setDefault(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGIONS, false);
+		store.setDefault(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_START, "#region"); //$NON-NLS-1$
+		store.setDefault(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_END, "#endregion"); //$NON-NLS-1$
 
 		// properties file editor
 		store.setDefault(PreferenceConstants.PROPERTIES_FILE_COLORING_KEY_BOLD, false);
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/text/folding/DefaultJavaFoldingStructureProvider.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/text/folding/DefaultJavaFoldingStructureProvider.java
index 380a005f898..5d7c953121f 100755
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/text/folding/DefaultJavaFoldingStructureProvider.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/text/folding/DefaultJavaFoldingStructureProvider.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2024 IBM Corporation and others.
+ * Copyright (c) 2006, 2025 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -13,11 +13,13 @@
  *******************************************************************************/
 package org.eclipse.jdt.ui.text.folding;
 
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -130,6 +132,10 @@ protected final class FoldingStructureComputationContext {
 		private IScanner fDefaultScanner; // this one may or not be the shared DefaultJavaFoldingStructureProvider.fSharedScanner
 		private IScanner fScannerForProject;
 
+		private Deque<Integer> fOpenCustomRegionStartPositions = new ArrayDeque<>();
+		private Set<Region> fCurrentCustomRegions = new HashSet<>();
+		private int fLastScannedIndex;
+
 		private FoldingStructureComputationContext(IDocument document, ProjectionAnnotationModel model, boolean allowCollapsing, IScanner scanner) {
 			Assert.isNotNull(document);
 			Assert.isNotNull(model);
@@ -268,6 +274,17 @@ public boolean collapseJavadoc() {
 		public boolean collapseMembers() {
 			return fAllowCollapsing && fCollapseMembers;
 		}
+
+		/**
+		 * Returns <code>true</code> if custom regions should be collapsed.
+		 *
+		 * @return <code>true</code> if custom regions should be collapsed
+		 * @since 3.34
+		 */
+		public boolean collapseCustomRegions() {
+			return fAllowCollapsing && fCollapseCustomRegions;
+		}
+
 	}
 
 	/**
@@ -1011,8 +1028,13 @@ public void propertyChange(PropertyChangeEvent event) {
 	private boolean fCollapseInnerTypes= true;
 	private boolean fCollapseMembers= false;
 	private boolean fCollapseHeaderComments= true;
+	private boolean fCollapseCustomRegions= false;
 	private boolean fNewFolding;
 
+	private boolean fCustomFoldingRegionsEnabled= true;
+	private char[] fCustomFoldingRegionBegin;
+	private char[] fCustomFoldingRegionEnd;
+
 	/* filters */
 	/** Member filter, matches nested members (but not top-level types). */
 	private final Filter fMemberFilter = new MemberFilter();
@@ -1189,7 +1211,14 @@ private void initializePreferences() {
 	    fCollapseJavadoc = store.getBoolean(PreferenceConstants.EDITOR_FOLDING_JAVADOC);
 	    fCollapseMembers = store.getBoolean(PreferenceConstants.EDITOR_FOLDING_METHODS);
 	    fCollapseHeaderComments = store.getBoolean(PreferenceConstants.EDITOR_FOLDING_HEADERS);
-	    fNewFolding = store.getBoolean(PreferenceConstants.EDITOR_NEW_FOLDING_ENABLED);
+
+		String customFoldingRegionBegin= store.getString(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_START);
+		String customFoldingRegionEnd= store.getString(PreferenceConstants.EDITOR_FOLDING_CUSTOM_REGION_END);
+		fCustomFoldingRegionBegin=customFoldingRegionBegin.toCharArray();
+		fCustomFoldingRegionEnd=customFoldingRegionEnd.toCharArray();
+		fCustomFoldingRegionsEnabled = !customFoldingRegionBegin.isEmpty() && !customFoldingRegionEnd.isEmpty() &&
+				!customFoldingRegionBegin.contains(customFoldingRegionEnd) && !customFoldingRegionEnd.contains(customFoldingRegionBegin);
+		fNewFolding = store.getBoolean(PreferenceConstants.EDITOR_NEW_FOLDING_ENABLED);
 	}
 
 	private void update(FoldingStructureComputationContext ctx) {
@@ -1443,7 +1472,15 @@ private void computeFoldingStructure(IJavaElement[] elements, FoldingStructureCo
 
 			if (element instanceof IParent) {
 				IParent parent= (IParent) element;
+				Deque<Integer> outerOpenRegions = ctx.fOpenCustomRegionStartPositions;
+				ctx.fOpenCustomRegionStartPositions = new ArrayDeque<>();
 				computeFoldingStructure(parent.getChildren(), ctx);
+				ctx.fOpenCustomRegionStartPositions = outerOpenRegions;
+			}
+			if (fCustomFoldingRegionsEnabled && element instanceof ISourceReference sourceRef) {
+				// mark as scanned until end after scanning all children
+				ISourceRange sourceRange= sourceRef.getSourceRange();
+				ctx.fLastScannedIndex = sourceRange.getLength()+sourceRange.getOffset();
 			}
 		}
 	}
@@ -1494,7 +1531,8 @@ protected void computeFoldingStructure(IJavaElement element, FoldingStructureCom
 			// comments
 			for (int i= 0; i < regions.length - 1; i++) {
 				includelastLine= true;
-				IRegion normalized= alignRegion(regions[i], ctx);
+				IRegion region= regions[i];
+				IRegion normalized= alignRegion(region, ctx);
 				if (normalized != null) {
 					includelastLine= true;
 					Position position= createCommentPosition(normalized);
@@ -1502,6 +1540,8 @@ protected void computeFoldingStructure(IJavaElement element, FoldingStructureCom
 						boolean commentCollapse;
 						if (i == 0 && (regions.length > 2 || ctx.hasHeaderComment()) && element == ctx.getFirstType()) {
 							commentCollapse= ctx.collapseHeaderComments();
+						} else if(ctx.fCurrentCustomRegions.contains(region)) {
+							commentCollapse= ctx.collapseCustomRegions();
 						} else {
 							commentCollapse= ctx.collapseJavadoc();
 						}
@@ -1590,24 +1630,40 @@ protected final IRegion[] computeProjectionRanges(ISourceReference reference, Fo
 
 				final int shift= range.getOffset();
 				IScanner scanner= ctx.getScanner();
+
+				if (fCustomFoldingRegionsEnabled &&
+						reference instanceof IJavaElement javaElement && javaElement.getParent() != null &&
+							javaElement.getParent() instanceof IParent parent && parent instanceof ISourceReference parentSourceReference) {
+						// check tokens between the last sibling (or the parent) and start of current sibling
+						ISourceRange parentSourceRange= parentSourceReference.getSourceRange();
+						if (ctx.fLastScannedIndex >= parentSourceRange.getOffset() && ctx.fLastScannedIndex < parentSourceRange.getOffset() + parentSourceRange.getLength()
+								&& ctx.fLastScannedIndex < range.getOffset()) {
+							scanner.resetTo(ctx.fLastScannedIndex, range.getOffset());
+							checkCustomFoldingUntilScannerEnd(ctx, regions, ctx.fOpenCustomRegionStartPositions, scanner);
+						}
+					}
+
+
 				scanner.resetTo(shift, shift + range.getLength());
 
 				int start= shift;
+
 				while (true) {
 
 					int token= scanner.getNextToken();
 					start= scanner.getCurrentTokenStartPosition();
 
 					switch (token) {
-						case ITerminalSymbols.TokenNameCOMMENT_JAVADOC:
-						case ITerminalSymbols.TokenNameCOMMENT_MARKDOWN:
-						case ITerminalSymbols.TokenNameCOMMENT_BLOCK: {
+						case ITerminalSymbols.TokenNameCOMMENT_JAVADOC, ITerminalSymbols.TokenNameCOMMENT_MARKDOWN, ITerminalSymbols.TokenNameCOMMENT_BLOCK: {
 							int end= scanner.getCurrentTokenEndPosition() + 1;
 							regions.add(new Region(start, end - start));
+							checkCustomFolding(ctx, regions, ctx.fOpenCustomRegionStartPositions, scanner, token, regions.size());
 							continue;
 						}
-						case ITerminalSymbols.TokenNameCOMMENT_LINE:
+						case ITerminalSymbols.TokenNameCOMMENT_LINE: {
+							checkCustomFolding(ctx, regions, ctx.fOpenCustomRegionStartPositions, scanner, token, regions.size());
 							continue;
+						}
 					}
 
 					break;
@@ -1615,6 +1671,27 @@ protected final IRegion[] computeProjectionRanges(ISourceReference reference, Fo
 
 				regions.add(new Region(start, shift + range.getLength() - start));
 
+				if (fCustomFoldingRegionsEnabled) {
+					if (reference instanceof IParent parent && !parent.hasChildren()) {
+						// if the element has no children, check content for custom folding region markers
+						checkCustomFoldingUntilScannerEnd(ctx, regions, new ArrayDeque<>(), scanner);
+					}
+					ctx.fLastScannedIndex= scanner.getCurrentTokenEndPosition();
+					if (reference instanceof IJavaElement javaElement && javaElement.getParent() != null &&
+							javaElement.getParent() instanceof IParent parent && parent instanceof ISourceReference parentSourceReference) {
+						IJavaElement[] siblings= parent.getChildren();
+						if (javaElement == siblings[siblings.length - 1]) {
+							// if the current element is the last sibling
+							// tokens after the current element and before the end of the parent are checked for custom folding region markers
+							int regionStart= range.getOffset() + range.getLength();
+							ISourceRange parentRange= parentSourceReference.getSourceRange();
+							int regionEnd= parentRange.getOffset() + parentRange.getLength();
+							scanner.resetTo(regionStart, regionEnd);
+							checkCustomFoldingUntilScannerEnd(ctx, regions, ctx.fOpenCustomRegionStartPositions, scanner);
+						}
+					}
+				}
+
 				IRegion[] result= new IRegion[regions.size()];
 				regions.toArray(result);
 				return result;
@@ -1623,6 +1700,63 @@ protected final IRegion[] computeProjectionRanges(ISourceReference reference, Fo
 		return new IRegion[0];
 	}
 
+	private void checkCustomFoldingUntilScannerEnd(FoldingStructureComputationContext ctx, List<IRegion> regions, Deque<Integer> openCustomRegionStartPositions, IScanner scanner) throws InvalidInputException {
+		for(int token = scanner.getNextToken(); token != ITerminalSymbols.TokenNameEOF; token=scanner.getNextToken()) {
+			if(isCommentToken(token)) {
+				checkCustomFolding(ctx, regions, openCustomRegionStartPositions, scanner, token, Math.max(regions.size() - 1, 0));
+			}
+		}
+	}
+
+	private boolean isCommentToken(int token) {
+		return token == ITerminalSymbols.TokenNameCOMMENT_BLOCK || token == ITerminalSymbols.TokenNameCOMMENT_JAVADOC || token == ITerminalSymbols.TokenNameCOMMENT_MARKDOWN || token == ITerminalSymbols.TokenNameCOMMENT_LINE;
+	}
+
+	private void checkCustomFolding(FoldingStructureComputationContext ctx, List<IRegion> regions, Deque<Integer> openCustomRegionStartPositions, IScanner scanner, int token, int regionArrayIndex) {
+		if (!fCustomFoldingRegionsEnabled) {
+			return;
+		}
+		int start = findPossibleRegionCommentStart(scanner, token);
+
+		if (startsWith(scanner.getSource(), start, scanner.getCurrentTokenEndPosition() - start, fCustomFoldingRegionBegin)) {
+			openCustomRegionStartPositions.add(start);
+		}
+		if (startsWith(scanner.getSource(), start, scanner.getCurrentTokenEndPosition() - start, fCustomFoldingRegionEnd) && !openCustomRegionStartPositions.isEmpty()) {
+			int end= scanner.getCurrentTokenStartPosition() + 1;
+			Integer regionStart= openCustomRegionStartPositions.removeLast();
+			Region region= new Region(regionStart, end - regionStart);
+			regions.add(regionArrayIndex, region);
+			ctx.fCurrentCustomRegions.add(region);
+		}
+	}
+
+	private int findPossibleRegionCommentStart(IScanner scanner, int token) {
+		char[] source= scanner.getSource();
+		int start = scanner.getCurrentTokenStartPosition();
+		int skip = switch(token) {
+			case ITerminalSymbols.TokenNameCOMMENT_LINE, ITerminalSymbols.TokenNameCOMMENT_BLOCK -> 2;
+			case ITerminalSymbols.TokenNameCOMMENT_JAVADOC, ITerminalSymbols.TokenNameCOMMENT_MARKDOWN -> 3;
+			default -> 0;
+		};
+		int newStart=start+skip;
+		while(Character.isWhitespace(source[newStart])) {
+			newStart++;
+		}
+		return newStart;
+	}
+
+	private boolean startsWith(char[] source, int offset, int length, char[] prefix) {
+		if (length < prefix.length) {
+			return false;
+		}
+		for(int i=0;i<prefix.length;i++) {
+			if (source[offset+i] != prefix[i]) {
+				return false;
+			}
+		}
+		return true;
+	}
+
 	private IRegion computeHeaderComment(FoldingStructureComputationContext ctx) throws JavaModelException {
 		// search at most up to the first type
 		ISourceRange range= ctx.getFirstType().getSourceRange();