AL

AL (Application Language) is a domain-specific programming language created by Microsoft for developing extensions for Microsoft Dynamics 365 Business Central. It replaced C/AL (Client/server Application Language), the proprietary language used in Microsoft Dynamics NAV since the 1980s, and represents Microsoft’s shift from monolithic, on-premises ERP customization to a modern, cloud-first, extension-based architecture. AL is developed exclusively in Visual Studio Code and cannot be used outside the Business Central ecosystem.

History & Origins

From Dynamics NAV to Business Central

AL’s origins are rooted in the history of Dynamics NAV, which traces back to the Danish company PC&C (later Navision Software) and its accounting software originally released in the late 1980s. That product used C/AL – a Pascal-derived language – and a proprietary IDE called C/SIDE (Client/Server Integrated Development Environment). Microsoft acquired Navision in 2002 and continued developing the product through several rebrandings: Navision, Microsoft Dynamics NAV, and ultimately Dynamics 365 Business Central.

Under the C/AL model, developers customized Business Central’s predecessor by directly modifying the core application code. This made upgrades extremely painful: every Microsoft update required merging custom changes with the new codebase, often leading to prolonged and error-prone upgrade projects.

The Modern Development Tools Preview (2016)

In late 2016, Microsoft introduced a fundamentally new approach. The microsoft/AL GitHub repository was created on November 25, 2016, under an MIT license. On December 20, 2016, Microsoft officially announced the “Preview of Modern Development Tools for Dynamics NAV,” revealing a new language and a Visual Studio Code extension that would replace C/SIDE. Community members had already begun experimenting with the tools by late November, with the first known public walkthrough appearing on November 29, 2016.

The new language – initially sometimes referred to informally as the “new NAV development language” before the AL name solidified – was designed from the start around an extension model: custom code would be packaged into self-contained apps that extend Business Central without modifying its core objects.

From Preview to Standard (2017-2019)

Throughout 2017, Microsoft released monthly developer preview updates (March, April, June, July, August, September, October, November, December), progressively adding features to AL and its VS Code tooling. Dynamics NAV 2018, released in December 2017, was the first shipped product version that supported both AL (via VS Code) and C/AL (via C/SIDE) side by side.

The defining moment came on April 2, 2018, when Microsoft Dynamics 365 Business Central launched publicly as a cloud-first ERP. AL was its standard development language. For the next year and a half, both AL and C/AL coexisted: Business Central version 14 (released April 2019) was the last version supporting both languages.

With Business Central version 15 in October 2019, Microsoft retired C/AL entirely. The legacy monolithic codebase was refactored into modular AL extensions – the System Application and Base Application – and all future development was required to use AL.

Design Philosophy

AL was designed with several core principles that distinguish it from its predecessor:

• Extension over modification: Custom code is packaged into self-contained apps that hook into the core application through events and extension objects, rather than directly editing source code
• Familiar syntax: AL intentionally maintains syntactic similarity to C/AL (and therefore to Pascal) to ease the transition for the large existing Dynamics NAV developer community
• Modern tooling: Development moved from the proprietary C/SIDE to Visual Studio Code, giving developers access to source control, IntelliSense, extensions, and the broader VS Code ecosystem
• Cloud-first architecture: Designed for deployment to Microsoft’s cloud infrastructure, with the extension model enabling independent app lifecycle management

Key Features

Object Types

AL development revolves around a set of core object types, each serving a specific purpose in the Business Central architecture:

Extension objects (TableExtension, PageExtension, ReportExtension, EnumExtension) allow developers to add fields, actions, and behavior to existing objects without modifying them.

Event-Driven Architecture

AL uses an event-subscriber model that decouples custom logic from the core application:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// Publishing an event
codeunit 50100 MyPublisher
{
    [IntegrationEvent(false, false)]
    procedure OnBeforePostSalesOrder(var SalesHeader: Record "Sales Header")
    begin
    end;
}

// Subscribing to an event
codeunit 50101 MySubscriber
{
    [EventSubscriber(ObjectType::Codeunit, Codeunit::MyPublisher,
        'OnBeforePostSalesOrder', '', false, false)]
    local procedure HandleBeforePost(var SalesHeader: Record "Sales Header")
    begin
        // Custom validation logic
        if SalesHeader.Amount > 100000 then
            SalesHeader.TestField("Approval Status", SalesHeader."Approval Status"::Approved);
    end;
}

Pascal-Derived Syntax

AL’s syntax reflects its Pascal heritage through C/AL, using begin/end blocks, var declarations, and the procedure keyword:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

codeunit 50102 CustomerManager
{
    procedure GetCustomerDiscount(CustomerNo: Code[20]): Decimal
    var
        Customer: Record Customer;
        Discount: Decimal;
    begin
        if Customer.Get(CustomerNo) then begin
            case Customer."Customer Price Group" of
                'GOLD':
                    Discount := 15.0;
                'SILVER':
                    Discount := 10.0;
                else
                    Discount := 0;
            end;
        end;
        exit(Discount);
    end;
}

Strong Typing and Built-In Data Types

AL is strongly typed with compile-time error detection. It includes business-oriented data types:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var
    Amount: Decimal;
    CustomerNo: Code[20];
    Description: Text[100];
    PostingDate: Date;
    EntryNo: Integer;
    IsActive: Boolean;
    CustomerName: Text;
    OrderTime: Time;
    CreatedAt: DateTime;

Record-Based Database Access

Database operations in AL use a record-oriented model with built-in filtering:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

procedure FindActiveCustomers()
var
    Customer: Record Customer;
begin
    Customer.SetRange(Blocked, Customer.Blocked::" ");
    Customer.SetFilter("Date Filter", '%1..%2', 20250101D, Today);

    if Customer.FindSet() then
        repeat
            // Process each active customer
            Message('Customer: %1 - %2', Customer."No.", Customer.Name);
        until Customer.Next() = 0;
end;

Development Environment

AL development is performed exclusively in Visual Studio Code with the AL Language extension published by Microsoft. The extension provides:

• IntelliSense with context-aware code completion
• Syntax highlighting and code formatting
• Snippets for common object types (tables, pages, codeunits, reports)
• Incremental compilation with diagnostic messages
• Debugging with breakpoints (F5 for debugging, Ctrl+F5 for publish without debugging)
• Symbol downloading from Business Central instances

A new AL project is initialized with the AL: Go! command (Alt+A, Alt+L), which creates the project scaffold including app.json (extension manifest) and launch.json (deployment configuration). The extension deploys directly to a Business Central sandbox environment for testing.

This replaced the legacy C/SIDE IDE, a proprietary Windows-only environment that stored code in a binary database rather than text files. The move to VS Code brought AL development into the modern ecosystem of source control, CI/CD pipelines, and collaborative tooling.

AL vs C/AL

The transition from C/AL to AL represented a fundamental shift in the Dynamics NAV/Business Central development model:

Evolution

Since its introduction, AL has steadily grown in sophistication:

• 2017-2018: Core language features, basic object types, initial extension model
• 2019: Full transition from C/AL; System Application and Base Application split
• 2020-2022: Collection types (List, Dictionary), HTTP/JSON support for web service integration, performance profiling tools
• 2023: Namespace support for organizing code in large projects
• 2024: Extendable interfaces enabling polymorphic patterns across extensions
• 2025: GitHub Copilot integration, MCP Server for Business Central preview, SQL call capture in performance profiles

Microsoft follows a twice-yearly release cadence (Wave 1 in spring, Wave 2 in fall) with regular cumulative updates between waves.

Current Relevance

AL is actively maintained with continuous investment from Microsoft. As of early 2026, the AL Language VS Code extension has approximately 484,000 installs and is at version 17.0. The microsoft/AL GitHub repository serves as the primary issue tracker and sample repository, with approximately 840 stars and active community engagement.

The broader ecosystem includes:

• microsoft/ALAppExtensions: Open-source repository where Microsoft and partners collaborate on add-ons and country-specific localizations
• microsoft/alguidelines: Official best practices and coding guidelines
• AL-Go for GitHub: DevOps template for CI/CD pipelines with GitHub Actions
• Microsoft Learn: Comprehensive documentation, training modules, and certification paths
• AppSource Marketplace: Distribution channel for third-party AL extensions

Business Central itself serves approximately 50,000 companies, primarily in the small-to-medium business segment, with strong adoption in the United States, Germany, and the United Kingdom.

Why It Matters

AL represents a case study in how enterprise software platforms modernize their development ecosystems:

1. Extension architecture: AL’s model of extending rather than modifying core code has dramatically simplified the upgrade path for Business Central customers, addressing one of the most persistent pain points in the Dynamics NAV ecosystem
2. IDE modernization: By moving from a proprietary IDE to Visual Studio Code, Microsoft gave AL developers access to the broader ecosystem of modern development tools, source control, and CI/CD practices
3. Cloud transition enabler: AL’s extension-based architecture was essential to making Business Central viable as a cloud service, where customers cannot modify core application code
4. Managed evolution: The deliberate syntactic similarity between C/AL and AL allowed Microsoft to transition a large developer community to a fundamentally different architectural model with minimal friction
5. Domain-specific by design: Unlike general-purpose languages, AL is tightly coupled to Business Central, making it deeply integrated with its target platform but exclusively tied to that ecosystem