A glowing split-flap version counter flipping from 18 to 30, surrounded by small icons for multi-field updates, Markdown text and code formatting.
Development

First Look at AL 30.0: What's Coming in Business Central 2027 Wave 1

Stefan Šošić
6 min read

The AL Language extension skipped eleven version numbers.

The current release is 18.1 (Business Central 2026 release wave 2). The next one - the first builds for Business Central 2027 release wave 1, published on 1 and 10 October 2026 - is 30.0. Not 19.0.

The reason is visible in the tooling itself. altool has a command that maps a platform version to the newest runtime it supports, and the 30.0 build answers like this:

Text
altool GetLatestSupportedRuntimeVersion 28.0  ->  17.1
altool GetLatestSupportedRuntimeVersion 29.0  ->  18.0
altool GetLatestSupportedRuntimeVersion 30.0  ->  30.0

For years the AL runtime ran about eleven numbers behind the Business Central major version. From BC 30 on, they are the same number. "runtime": "30.0" goes with BC 30. That alone will save a lot of "which runtime do I need for v2X?" lookups.

Everything below comes from the compiler and language server in the 30.0.2863738 VSIX (compiler 30.0.43.45776), run against the BC 29 symbols - there are no BC 30 symbols public yet, so this is compile-time behaviour only.

Warning

This is a preview. Features can still change before the release. The compiler happily builds a "runtime": "30.0" app against BC 29 symbols - don't read that as "it will run on BC 29". Don't ship anything on runtime 30.0 yet.

ModifyAll with several fields at once#

ModifyAll now takes up to five field/value pairs, on both Record and RecordRef. RunTrigger stays optional and last.

AL
procedure BlockDomesticCustomers()
var
    Customer: Record Customer;
begin
    Customer.SetRange("Customer Posting Group", 'DOMESTIC');
    Customer.ModifyAll(Blocked, Customer.Blocked::All, "Payment Terms Code", 'CM', true);
end;

procedure ClearAmounts(var RecRef: RecordRef; AmountFieldNo: Integer; DescriptionFieldNo: Integer)
begin
    RecRef.ModifyAll(AmountFieldNo, 0, DescriptionFieldNo, 'Cleared');
end;

RecordRef.ModifyAll is brand new - even a single pair needs runtime 30.0, and the compiler says so clearly:

Text
error AL0666: 'ModifyAll' is not available in runtime version '18.0'. The supported runtime
versions are: '30.0' or greater.

The error messages are less helpful than they could be#

On Record, the multi-pair form on runtime 18.0 does not produce that clear message. You get this instead:

Text
error AL0118: The name '"Payment Terms Code"' does not exist in the current context.

The same thing happens on runtime 30.0 when you pass a sixth pair - the sixth field is reported as not existing:

Text
error AL0118: The name 'Contact' does not exist in the current context.

My reading: the compiler only resolves field names in valid pair positions. Outside those, it treats the identifier as a normal variable, doesn't find one, and reports AL0118. So if you see AL0118 on a field that clearly exists, count your pairs and check your runtime.

Two more things I tried:

  • A wrong value type is caught properly: Customer.ModifyAll(Blocked, 'not an option', Name, 'x') gives AL0193: Argument 2: cannot convert from 'Text' to the type of Argument 1 'Enum Microsoft.Sales.Customer."Customer Blocked"'.
  • The same field twice - Customer.ModifyAll(Name, 'a', Name, 'b') - compiles without a warning. Which value wins is a runtime question. Don't do it.

Why it matters#

Each ModifyAll call is its own UPDATE ... WHERE ... against the same filter. Two fields used to mean two passes over the same rows. In my Performance Patterns series the advice was to batch writes where you can; this is the platform doing it for you.

How much faster it is depends on what the server does with it, and the compiler can't tell you that - there is no BC 30 environment to measure against yet. What the API already guarantees is one call and one pass over your filter in AL, and RunTrigger applies to the whole call.

Markdown page fields#

A new ExtendedDatatype = Markdown renders a text control as Markdown:

AL
page 50300 "Release Note Card"
{
    PageType = Card;
    SourceTable = "Release Note";

    layout
    {
        area(Content)
        {
            group(Notes)
            {
                field(Body; Rec.Body)
                {
                    ExtendedDatatype = Markdown;
                    MultiLine = true;
                }
            }
        }
    }
}

The restrictions are strict. I tried each one against the 30.0 compiler, and every rule has its own error:

What I triedResult
Rec.Body (a Text table field)compiles
A Text variablecompiles
A procedure returning Textcompiles
Without MultiLine = trueAL0223: The Property 'ExtendedDatatype = Markdown;' can only be used if the property 'MultiLine' is set to 'true'
A second field in the same groupAL0934: The Markdown control 'BodyVar' must be the only control in a root-level group in the Content area.
The group nested inside another groupAL0934 (same message)
BodyText + 'x' (concatenation)AL0933: The source expression of control 'BodyCat' must be of type Text when ExtendedDatatype is Markdown.
A Code[20] variableAL0933 (same message)
ExtendedDatatype = Markdown on the table fieldAL0800: The field 'Body' specifies ExtendedDataType 'Markdown'. This ExtendedDataType can only be set on a control.
Runtime 18.0AL0666: 'Markdown' is not available in runtime version '18.0'.

The changelog's "direct table-field declarations are not supported" had me worried that Rec.Body would be rejected. It isn't - what is not supported is setting the property on the table field (AL0800). Binding a page control to a Text table field is fine.

Obvious uses: Copilot output (which is Markdown already), release notes, instructions on setup pages.

A new formatter (and diffs in lines you didn't touch)#

This one will affect everyone. The formatter now applies CodeCop-compatible layout for operators, blocks and control keywords, while keeping empty blocks and single-property blocks compact.

To see what that means in practice, I sent the same file through the formatting request of both language servers (altool launchlspserver from 18.1 and from 30.0). Input:

AL
table 50901 "Fmt Table"
{
    fields
    {
        field(1; "Code"; Code[20]) { Caption = 'Code'; }
        field(2; Description; Text[100]) { }
        field(3; Amount; Decimal)
        {
            Caption = 'Amount'; DecimalPlaces = 2:5;
        }
    }
    keys { key(PK; "Code") { Clustered = true; } }

    trigger OnInsert()
    begin
        if Amount<0 then Error('Negative');
        if Description='' then exit;
        Amount:=Round( Amount ,0.01 );
    end;
}

Both versions fix the spacing (Amount < 0, Round(Amount, 0.01), DecimalPlaces = 2 : 5), split the two properties onto separate lines, and keep { Caption = 'Code'; } and { } compact. The difference between 18.1 and 30.0 is exactly this:

DIFF
-    keys { key(PK; "Code") { Clustered = true; } }
+    keys
+    {
+        key(PK; "Code") { Clustered = true; }
+    }
 
     trigger OnInsert()
     begin
-        if Amount < 0 then Error('Negative');
-        if Description = '' then exit;
+        if Amount < 0 then
+            Error('Negative');
+        if Description = '' then
+            exit;

So: if ... then <statement> on one line gets split, and a section block containing another block gets expanded. Every codebase has a lot of one-line if ... then exit;, so expect those to show up in your diffs the first time you format a file with 30.0.

Interestingly, a one-line while (Fee > 100) and (Days <> 0) do Fee := Fee - 1; came out unchanged in both versions.

If you need the old behaviour - for example while half the team is still on 18.x - the changelog gives you a VS Code setting:

JSON
{
    "al.legacyFormatting": true
}

One caveat from my testing: the standalone language server (altool launchlspserver, which agents use) ignores that setting, even in .vscode/settings.json - it always formats the new way. That is in line with the changelog, which says the setting restores the old behaviour "in Visual Studio Code" and that "BCal always uses the improved behavior".

Tip

Agree on this per repo, not per developer. And when you switch to the new formatter, do it in one dedicated "format everything" commit so the real changes stay reviewable.

Smaller language and compiler changes#

From the changelog:

  • AL0720 - the compiler now reports when an InherentPermissions attribute in one project references an object from another project in a multi-root workspace.
  • Word layouts with INCLUDETEXT / INCLUDEPICTURE field codes now produce a compiler warning.
  • Excel layouts no longer change on every build when a dataitem name can't be used as an Excel sheet name (longer than 31 characters or containing @ : / \ * ? [ ]). If an Excel layout kept showing up as modified in git, this was why (#8001).
  • Event subscriber ordering is now consistent when metadata-based event binding is enabled.
  • Packaging no longer fails when a source or layout file name contains (, ), ', # or ? (#8267).

Tooling: altool grows up#

altool 30.0 gets downloadsymbols (works without any server, from Microsoft's NuGet feeds), listtests (works fully offline on an .app file), and code coverage for runtests in BC JSON or Cobertura format. I ran all of them; that's its own post: AL Without VS Code.

Debugging and editor fixes worth knowing#

  • Breakpoints in report request page triggers (OnInit, OnOpenPage) are hit again (#8171).
  • Breakpoints in install and upgrade codeunits work again when publishing while an attach session is waiting (#8129).
  • Separate test profiles for debugging with or without publishing, so tests in apps deployed in global or per-tenant scope can be debugged (#8244).
  • The language server reloads files changed outside VS Code - switching branches no longer leaves stale content behind (#7891).
  • Code actions no longer block other language server messages, which could prevent saving AL files (#8134).
  • al workspace compile works on macOS and Linux (#8326).

For agent users#

If you use the AL MCP / agent tools (I wrote about the v17.0 tools):

  • al_publish and al_debug accept a named launch configuration, so they no longer stop for an interactive prompt (#8274).
  • al_publish no longer hangs after publishing a full dependency tree (#8280).
  • al_compile, al_build and al_getdiagnostics no longer return stale results after a dependency project changed (#8325).
  • al_symbolsearch finds objects by exact object ID, and pages its results with continuation tokens.

Should you install it?#

On a dev machine with a matching sandbox - yes, mostly for the formatter, so it doesn't surprise you later. For anything you ship, stay on 18.x until the release.

Related posts

Comments

    Leave a comment

    Reviewed before it appears. Privacy