MPS 2026.1 Early Access: Key Features and Improvements

The MPS 2026.1 Early Access Program (EAP) has officially launched, bringing a host of new features and refinements to the language workbench. This release focuses on platform modernization, smarter language tools, and enhanced editing capabilities. Below, we answer the most pressing questions about this update.

1. What is the MPS 2026.1 Early Access Program?

The MPS 2026.1 EAP gives developers an early look at the next major version of JetBrains MPS (Meta Programming System). The program starts today with the first EAP build, which you can download and test immediately. This early release is packed with bug fixes and key improvements, including a migration to the latest IntelliJ Platform, JDK 25, and Kotlin 2.3. By participating, you can provide feedback that shapes the final release. The EAP is open to all users, and no special license is required—just download and try the new features in your projects.

2. How does the migration to IntelliJ Platform 2026.1, JDK 25, and Kotlin 2.3 benefit MPS?

This EAP build completes the move to the current generation of the IntelliJ Platform, bringing MPS up to date with the latest underlying infrastructure. With JDK 25, you get improved performance and security. The embedded Kotlin version is now 2.3.0, which offers better language support and compatibility. Additionally, MPS now builds and ships its own kotlinx-metadata-klib and kotlin-metadata-jvm artifacts from the Kotlin repository at the matching 2.3.0 tag. This restores KLib-based Kotlin stubs support, which the last public kotlinx-metadata-klib:0.0.6 could no longer provide. This means you can work with Kotlin modules more reliably, especially when using Kotlin Multiplatform projects.

3. How does the new ICheckedNamePolicy check against specific natural languages work?

MPS now uses the IntelliJ Platform’s natural language support, powered by Grazie. This allows you to verify that string values in ICheckedNamePolicy instances—such as intentions, actions, or tools—have proper capitalization according to the rules of a specific natural language. You can install natural language support for select languages, and the IDE will detect the language used in strings and ensure words are capitalized correctly. If you want to bypass automatic detection, you can specify your desired language explicitly. This feature helps maintain consistent naming conventions across your language definitions, especially when working in multilingual teams.

4. What are the capitalization options available besides Title-case?

In addition to the default Title-case capitalization rules, MPS offers three other options for ICheckedNamePolicy:

• Sentence-case—follows the IntelliJ Platform’s rules for sentence capitalization.
• Inherited—uses the capitalization rules of the closest ancestor ICheckedNamePolicy.
• No capitalization rules—disables all automatic capitalization checking.

These options give you fine-grained control over how names are validated. For example, you might use Title-case for action names but Sentence-case for tooltips. The inherited option allows you to set a base policy and override it only where needed, reducing repetition in your language definitions.

5. How can users split binary operations into multiple lines in the editor?

In the editor, you can now split long lines containing binary operations into multiple lines for better readability. MPS provides a dedicated intention action that toggles between single-line and multi-line layouts for a given BinaryOperation. This is especially useful when you have complex expressions that would otherwise stretch horizontally. Simply place the caret on the binary operation, invoke the intention action (Alt+Enter or via the lightbulb), and choose to split or join the lines. The multi-line layout automatically indents the operands for clarity. This feature works with any binary operation, such as arithmetic, logical, or comparison expressions, making your code easier to read and maintain.

6. What is the new read-only-inspector style and how does it work?

The new read-only-inspector style enforces a read-only property on all editor cells in the inspector. When you apply this style to a cell in the main editor, the inspector becomes read-only for the inspected node when that cell is selected. Key properties: it is disabled by default; it is inheritable and overridable (just like the regular read-only style); it has no effect on main editor cells; and the read-only state set by this mechanism can be overridden in any cell deeper in the inspector editor cell tree. This is useful when you want to prevent accidental modifications in the inspector without restricting edits in the main editor. For example, you could make a node’s documentation read-only in the inspector while still allowing the user to edit other properties.

7. How have transitive dependencies been improved in Build Language?

Build Language no longer requires every transitively-reachable build script to be listed explicitly in dependencies. Previously, if BuildA depended on BuildB and BuildB depended on BuildC, you had to list BuildC as a direct dependency of BuildA as well. Now, BuildA can reach BuildC through BuildB without an explicit reference. The generator emits ${artifacts.BuildC} Ant properties for such cases, and these properties can be supplied from the outer build tool (Gradle, Maven, etc.). This reduces dependency boilerplate and simplifies build script management, especially in large projects with complex dependency graphs.