Native Code in BC28 AL, a Mystery!

Poking around in BC28, fellow MVP AJ Kauffmann noticed a bit of a mystery, a new attribute in AL called [Native]. Join me in the video to investigate the mystery!

https://youtu.be/ksOuq4Y2JhM

In this video, Erik explores a mysterious new keyword that appeared in Business Central 2026 Wave 1 (BC28): the Native attribute. Tipped off by fellow MVP AJ Kaufman, Erik dives into what this keyword means, where it shows up, and speculates on what it could signal for the future of AL development.

Semantic Search: The Starting Point

The mystery begins with a new feature in BC28: semantic search. In Business Central 28, the “Tell Me” search functionality has been enhanced with semantic capabilities. This means you can search for terms that don’t exactly match anything in the system, and it will still return relevant results.

For example, if you search for “clients” — a word that doesn’t exist anywhere in Business Central’s vocabulary — the advanced search will return results that are “client-ish,” like customer-related pages and reports. This is particularly useful when users don’t know the exact Business Central terminology but know a word that’s close enough.

Discovering the Native Keyword

Microsoft has exposed semantic search capabilities to AL developers through a new codeunit. When you look up the available procedures, you’ll find something like FindSimilarByField. But here’s where it gets interesting — if you press F12 to peek at the definition of these procedures, you’ll see something unexpected:

[Native]
procedure FindSimilarByField(...)

The procedures are decorated with a [Native] attribute. This is the mystery.

What Is the Native Attribute?

Erik investigates by attempting to use the attribute himself. The IntelliSense description reads:

“Specifies that the method is a native method. Restricted to Microsoft only.”

Attempting to use it on a method inside a page or other object yields an error:

Attribute 'Native' can only be used within a codeunit.

Fair enough — so Erik creates a codeunit and tries again:

codeunit 50100 "Native Stuff"
{
    [Native]
    procedure Test()
    begin
    end;
}

This produces another error:

The native procedure 'Test' can only be declared in the system object ID range within the platform symbol app.

So the [Native] attribute is locked down to Microsoft’s platform-level codeunits. Third-party developers cannot use it — at least not yet.

What Does This Mean?

What’s clearly happening is that these AL procedures are backed by native code — likely C# code running in the platform layer. The AL declaration acts as a public surface for functionality that’s implemented at a deeper level than AL can reach.

But this raises an interesting architectural question: why not use an interface? If there’s a native implementation behind these procedures, it would seem more natural to declare an interface in AL and have the platform provide the implementation. Instead, Microsoft has opted for what Erik describes as a “pseudo interface” — a codeunit with procedure signatures that are explicitly marked as having no AL implementation.

The Conspiracy Theories

Every good mystery needs some conspiracy, and Erik offers a few possible explanations:

  1. The pragmatic explanation: Microsoft simply needed a way to expose internal platform functionality to AL developers, and the [Native] attribute was the easiest mechanism to achieve that. Nothing more, nothing less.
  2. The exciting speculation: Could this be a precursor to a mechanism where partners could eventually supply their own DLLs or .NET assemblies to Microsoft and get access to native code execution again? Could this be a path back to .NET interop in some controlled fashion?
  3. The interface question: Is Microsoft prototyping a new pattern for platform-AL integration that might evolve into something more extensible?

Conclusion

The [Native] attribute in BC28 is a fascinating discovery — a new keyword that’s currently restricted to Microsoft’s platform codeunits, backing AL procedure declarations with native C# implementations. Whether this is simply an internal plumbing detail that happened to become visible, or a hint at something bigger on the horizon, remains to be seen. Thanks to AJ Kaufman for spotting it and bringing it to the community’s attention. As Erik puts it: “It’s a mystery” — and it’s the kind of mystery that makes following Business Central development so interesting.

Picture of hougaard

hougaard