The old Prism tool for C/AL has come in a version for AL. In this video, I take a first look at the tool:
You can find the tool here: https://stati-cal.com/PrismForAL/Try
In this video, Erik takes a first look at Prism for AL, a new tool from Static Studies that brings powerful cross-reference and code analysis capabilities to the AL development world. If you remember the original Prism for C/AL, this is its spiritual successor — and Erik takes it for a test drive live, sharing his impressions as he explores the features.
What is Prism for AL?
Prism was originally a popular tool for C/AL developers that provided cross-reference capabilities, “find where used” functionality, and other code navigation features that were sorely missing from the C/SIDE development environment. While Visual Studio Code has brought many of these features to AL development, Prism for AL offers a different perspective — a dedicated analysis tool with its own UI and some capabilities that go beyond what VS Code currently provides.
The tool is available at staticstudies-cal.com and offers a trial key so you can test it out yourself.
Getting Started: The Control Panel
When you launch Prism for AL, you’re greeted with a control panel that offers three main modes:
- Workspace — browse your AL workspace
- Modules — explore individual modules/extensions
- Direct Dependency — view dependencies, with multi-level (recursive) dependency analysis available
Note that the first time you open a project, it takes some time to load and cache everything. Subsequent loads are noticeably faster thanks to caching.
Exploring a Project: BC Script Extension
Erik opens the BC Script extension as his first test case. The start page provides an overview of the module, showing that it contains 33 objects with dependencies on the Microsoft Base Application (which has 6,544 objects). On the left side, a tree view displays the different object types within the module.
Page Viewer
Clicking on a page (in this case, the Scratch Pad page) reveals a formatted view that’s quite different from what you see in Visual Studio Code. The page is displayed with clearly organized sections:
- Properties — caption, page type, etc.
- Global Variables
- Triggers — such as OnOpenPage
- Controls — area, grid, and individual controls, all nicely formatted
- Procedures — EvalCode, Execute, PrettyJSON, DownloadJSON, DumpExpression, etc.
Find Usage
One of the core features is the ability to right-click on a variable or symbol and select Find Usage. For example, right-clicking on a variable like UseConsole shows exactly where it’s used — on the OnOpenPage trigger, in a control, and twice in a procedure. This is a powerful way to trace how variables flow through your code.
Clicking on a reference like Interpreter.RunUnit navigates directly to that symbol, and the Find Usage feature shows all references across multiple objects — for instance, usage in both the Scratch Pad and the Web Pad pages.
Tables, Keys, and System Function Usage
Switching to the Tic-Tac-Toe sample project, Erik explores table-related features. One standout capability that you cannot do in Visual Studio Code is finding usage of a key. While this is less impressive with a primary key, it becomes very useful in larger applications.
Find System Function Usage
This is where Prism for AL really shines. Right-clicking on a table and selecting Find System Function Usage lets you answer questions like:
- Where do I insert records into this table?
- Where do I delete records from this table?
- Where do I modify records?
- Where do I use Reset on this record?
Erik also notes that Clear is not yet available in the system function search — a feature he hopes will be added in a future version, especially for finding where Clear is used on record variables.
Exploring Enums and the Base Application
Enum Value Usage
Prism lets you find where specific enum values are used. For example, you can right-click on an enum value like “Blank” or “Cross” and find every place in the codebase where that specific value is referenced. This is incredibly useful for understanding how enum values flow through your application logic.
Searching the Base Application
Erik dives into the Base Application to test the tool at scale. Searching for system function usage on the Sales Line table — specifically, where sales lines are inserted — returns 81 results across the base app. The search takes about 12–14 seconds, which is reasonable given the size of the base application.
A nice touch: when you click on a system function like Insert, Prism shows you the documentation/manual entry for that function, complete with parameter details. As Erik notes: “Microsoft, you should take notice of that one — that’s actually pretty nice.”
Page Usage and Module Relations
Right-clicking on a page and selecting system function usage reveals everywhere that page is being run — in lookup mode, run mode, and other contexts. This is invaluable for understanding the navigation flow of an application.
Prism also includes a Show Module Relations feature that visualizes the dependency graph between your extensions. For example, the Tic-Tac-Toe extension shows its dependency on the Application module.
Erik also noticed that Prism appears to have some level of Git integration, with references to branches (like “master”) visible in the UI, though he didn’t fully explore this feature in the video.
Impressions and Takeaways
Erik’s overall impression of Prism for AL is very positive. Here are the highlights:
- Find Usage across objects and modules is well-implemented
- Find System Function Usage is a standout feature — knowing where records are inserted, deleted, or modified across an entire application is extremely powerful
- Enum value tracking is useful and not easily replicated in VS Code
- Code review — the formatted, structured view of objects makes this a great tool for reviewing code
- Documentation integration for system functions is a thoughtful touch
- The nicely formatted object views present code differently than VS Code, which can be helpful for understanding structure
Areas for improvement include the lack of UI scaling options (which made it tricky to demo at low resolution) and the initial load times for large projects. The inability to find Clear usage is a minor gap that will hopefully be addressed.
Conclusion
Prism for AL is a promising new tool for AL developers who want deeper code analysis capabilities beyond what Visual Studio Code currently offers. Its ability to trace system function usage across entire applications — like finding all 81 places the base app inserts sales lines — makes it particularly valuable for code reviews, refactoring, and understanding complex codebases. If you’re working with Business Central AL development, it’s worth taking for a spin while trial keys are available at staticstudies-cal.com.
