Press the Get trial license link in the Control panel:

The Trial license window now pops up:

Enter your details and press the Submit button. We will immediately email your trial license to the email address you have entered.

Open your email client, fetch new mails and open the email from us. You can now go ahead and install the trial license.

Copy the license key we emailed to you to the clipboard. Make sure to copy the whole key.

In Prism for AL's Control panel, press the Enter license which opens the License key window:

Paste in the license key and click Activate. You are now ready to open your first workspace.

Prism for AL features a number of ways to open a solution. You probably already have a Visual Studio Code AL project available, so to get started, here is what you do:

First, make sure you have used AL: Download symbols in Visual Studio Code. This is because Prism for AL needs access to the dependencies.

Then, if you have a .code-workspace file, click the button Open workspace in the Control panel and select the .code-workspace file.

Else, if you have Visual Studio Code AL project folder, click the button Open folder in the Control panel and select the folder.

Prism for AL will now load all objects including those defined in dependent packages. The first load of new package is always slower due to Prism filling its cache. You can speed up first time loads by excluding Prism for AL's cache folder from virus scanning, see Package cache.

You are now ready to browse code and analyze your code including Base Application and other dependencies. Check out the next section for your possible next steps.

Depending on your learning preferences, do any of the following or mix them to familiarize yourself with Prism for AL:

• Throw yourself into it – use tooltips to discover
• Read about Using Prism for AL.
• Watch a video.
• Read or scan the Reference manual.

If you get stuck or have any questions, simply email us at feedback@stati-cal.com.

The following table gives an overview over which features are available per declaration kind. This influences whether the corresponding menu items are available in a declaration's context menu.

The matrix entries have the following meaning:

• Always: The feature is always enabled for the declaration kind.
• Full: The feature is enabled when a full code graph is loaded.
• Procedural: The feature is enabled when a code graph is loaded (full or procedural).
• (blank): The feature is not enabled for the declaration kind.

├───app-A
│   │   app.json
│   │   DoThis.Codeunit.al
│   │
│   └───.alpackages
└───app-B
│   app.json
│   DoThat.Codeunit.al
│
└───.alpackages

Search depth values (dotted lines in the pictographs are propagated dependencies):

Mnemonic	Description	Pictograph
W	Workspace: Workspace modules (app.json), only. No packages are included.
W→P	Workspace and direct dependencies: Workspace modules (app.json) as well as direct package dependencies (*.app)
W→PP	Workspace and direct/propagated dependencies: Workspace modules (app.json) as well as direct package dependencies (*.app) and their propagated dependencies.
W→P→*	Workspace and transitive dependencies: Workspace modules (app.json) and all dependencies transitively (recursively)." Notice that this setting may lead to unexpected results as old, now unused packages in Visual Studio Code .alpackages folders may be included.

File menu:

Help menu:

Recent context menu:

The Loading window is opened when opening a workspace. The main activities are:

• Locate workspace app.json file(s)
• Locate available package files (typically in .alpackages, but depends on setup in Visual Studio Code)
• Parse app.json
• Parse NavxManifest.xml files from packages
• Resolve dependencies from app.json and NavxManifest.xml taking into account the dependency declaration's version. Package resolution is influenced by package resolution options.
• Parse .al files from workspace folders and packages where source code is available
• Parse SymbolReference.xml for packages where source code is not available
• Index object members and object level dependencies

File menu:

The primary purpose of the package cache is to optimize load performance. A secondary purpose is to allow package resolution to include packages not found in the workspace, see Search depth. Basically, the cache consists of artifacts extracted from .app files. The location of the cache is %LOCALAPPDATA%\Statical\PrismAL\PackageCache.

Prism for AL writes to the cache during loading when encountering a new package or a new version of a known package. Anti-virus programs can slow down this process significantly, so – if your security policy allows – you may consider excluding the cache folder from being scanned. If you are using Windows Defender, you can use PowerShell to exclude Prism for AL's cache directory. See below how to obtain a PowerShell script for Windows Defender. For other anti-virus programs, please check the documentation.

When no license is installed, the control panel's license part has a link that opens the trial license page. Submit your details to receive a trial license by email. If you have recently received a trial license from us, we may reject the request. Of course, you can always contact us a ask politely for another trial if you are not yet convinced of subscribing.

The license key window is accessed from the control panel. When you have received a license key for your subscription or a trial license key, enter it in the License key window:

The Feedback window is available from menus in both the Control panel and the Workspace window.

Use the window to give us feedback such as:

• Ideas for new features
• Ideas for changes to current features
• Bug report
• Your favourite feature
• Example of hard problem you solved with Prism
• …

The workspace window is Prism's main window once a workspace has been opened:

File menu:

View menu:

Search menu:

History menu:

The history menu lists all objects and places within objects which you have navigated to or from since the workspace was opened. The history is in reverse chronological order and marks the last visited entry with green colour.

Click any history item to re-navigate. Re-navigation does not affect the history other than green marking. You can also navigate history with the back and forth arrows.

Reports menu:

Help menu:

Namespace name formatting options:

This combobox controls how object references are formatted.

The solution window opens once Prism has loaded a workspace. It consists of two or three tabs:

• General: Module overview
• Discovery: Package resolution overview
• Code Graph: Graph generation status, graph server management, and metrics of the code graph. This tab is only visible with a code graph is being generated or has been generated.

Once you select an object, the solution window closes. Use the Solution button to open the solution page again.

The General tab contains a table of modules that Prism has tried to resolve:

If you see any parse errors on this page, please refer to the parse error troubleshooting section.

All data originates from app.json files for workspace folders and NavxManifest.xml files for packaged modules (.app files). Below we will refer to this data as module metadata. From the detail view we describe only special fields not directly copied from module metadata.

The Discovery tab contains a table of package files that Prism for AL has considered while loading:

While generating a code graph, the Code Graph tab contains the generation status and metrics:

Once the graph has been generated, the status section is replaced by Management:

Use the object index to get an overview of objects and search for specific objects:

Objects are presented in a (configurable) hierarchy with the objects as leaves:

Module context menu:

Object context menu:

Use the settings dialog to control grouping and sorting:

Change settings as described below, then click somewhere else for the changes to take effect. Notice that these settings are per open workspace and they are not persistent (they are reset back to default next time you open Prism for AL.)

This view is shown when it has been selected via the View selector. The object view presents the full details of the object as a logical structure using icons, colours, module annotations etc:

When a code graph has been generated for the workspace, immediate insights are available above procedures and triggers:

Immediate insights context menu:

Events are highlighted with icons:

When TransferFields is used on two different tables, a special context menu is available:

Identifiers that reference a declaration have tooltips and you can click to navigate to the declaration:

Following navigation, a little red dot will high-light the navigation target. Also, the navigation history is updated, so hitting the back button after navigation will bring you back to the navigation source.

When clicking an identifier that resolves to a built-in function, a window with Microsoft's official documentation is opened in your default browser.

Identifiers that declare something, e.g. variables, procedures, fields etc, offer Find usages via left-click:

The default declaration context menu is:

See Declaration search feature matrix for information about which search features are available for which declarations and when.

Procedures (including event publishers and subscribers) offer additional functionality via the context menu:

The additions are:

A context menu is available anywhere in the object view, properties, code lines etc:

Code sections of procedures and triggers offer the following context menu:

Code lines of procedures and triggers can be selected and be actioned in various ways Left-click the area to the right of the vertical bar on the start and end line. The area will be marked with symbol, and the start and end indicators offer a context menu:

Based on data in XLIFF files, Prism shows translations in place in the selected language. Hover over the translation symbol to see how there the translation originates. In case multiple translations are available for the same language, all translations are displayed in priority order with a 'disqualification' reason.

This view is shown when it has been selected via the View selector and is also the default view. The extended view is similar to the Object view but inlines items defined in the object's extensions:

Notice that if multiple extensions try to e.g. add controls before a certain control, the outcome depends on the order in which the extension actions are applied. Prism applies changes in the topological order induced by the module dependencies, just like Business Central's runtime.

The source view is shown when it has been selected via the View selector. You can also get to the source view by other means:

• Go to position menu in the Workspace window.
• Go to source menus from Object view and Extended view.

The dependencies view gives an overview of how other objects use the current object and how the current object uses other objects. The view is selected with the View selector and has sections for Used by (incoming references) and Using (outgoing references)

Hold the Shift key and select one or more columns to sort. Multiple click on the same column reverses the order.

The object outline is a tree structured index of the object contents and is both part of the workspace window and can also be opened in a separate window in several ways. This allows you to have outline windows open for multiple objects.

As part of the workspace window, the outline follows the current object when the windows was opened. When opened as a separate window, the window sticks to the object that was current/selected when opened.

The outline settings provides detailed configuration options:

Here follows a description of the non-obvious settings:

When outline settings have checked Extensions, then only items inlined from extensions are displayed:

Click an item in the outline to navigate to the declaration in the current workspace view.

Right-click to activate the same context menu that is available in Object view and Extended view,

Overloaded procedures are marked with a counter and navigation arrows that indicate if more overloads exist either prior to or following a procedure:

The code fragment window can be open from code sections or by selecing code lines. Use the fragment window to remember interesting code fragment for your own purpose or for sharing with a colleague.

This dialog is invoked from the object context menu Find Built-in Function Usages. The dialog allows you find where certain instance methods are called on the target object. You can think of usages being on the form TargetObject.BuiltInFunction, although the process of course also finds usages where the object is implicit as it is in with statements and when used without preceeding rec. via e.g. the SourceTable property.

Select which instance methods to search for (multiple selections are allowed):

Find usages of can be invoked on declaration identifiers in multiple places:

• Declarations in Object view and Extended view (LeftClick)
• Declarations in Object outline
• The Usages window itself via context menu on blue and bold identifiers in headers

When the target of built-in function usages is a table, then the following filter options appear:

The Flows window is used in a number of flows scenarios. The data is queried from the code graph and the result view shows contextualized nodes, both syntax nodes and dispatch nodes (see below) that satisfy the criteria.

The window is used in the following scenarios:

• Inbound flows: Flows to a specific declaration.
• Outbound flows: Flows from a specific declaration.
• Shortest path: A shortest path between two nodes.
• Reachable committing procedures and triggers: Procedure and triggers that are reachable from a certain declaration and may call Commit.
• Reachable RIMD invocation sites: Procedure, triggers and dispatch nodes that are reachable from a certain declaration and perform RIMD operations.

Inbound flows and Outbound flows can be invoked from context menus on declaration identifiers:

• Declarations in Object view and Extended view
• Declarations in Object outline

We use the following types of flow nodes:

• Flow nodes:
  • Syntax nodes: Elements from AL's syntax trees, such as statements, expressions, identifiers, and operators.
  • Dispatch nodes: These are nodes that are not represented in AL's syntax, but still play a role in execution of AL code:
    • Runtime: Special nodes that represent a state in program execution, such as RunCodeunit, which represents the state that a codeunit must be run. In that way, runtime nodes provide the "glue" between calls to Codeunit.Run() and the Codeunit's OnRun trigger.
    • User: Represents the state where a user has interacted with Business Central. For example, an Action node represents a state when a user has clicked a button and a PageFieldValidation node represents a state where a user has entered data and left a field causing validation.
• Context nodes: Context nodes show the syntactic context of flow nodes all the way to the module level. Some nodes are both context nodes and flow nodes, such as procedures. We use the flow node symbol for these.

The level of detail in general depends on whether the graph was loaded as a full graph or as a procedure-level graph. However, for Reachable committing procedures and triggers and Reachable RIMD invocation sites, detailed syntax is never displayed.

The result of selecting Find shortest path in the context menu of a flow node is that a new flow window is opened in a mode where:

• Only nodes on a shortest path between the two flow nodes are displayed.
• The ordering of the flow nodes is step-by-step in the order given by the path.
• Flow nodes are numbered.
• The same context may appear more than once (e.g. when codeunit A calls something in codeunit B, then something in codeunit C, then something in codeunit B again.)

The Procedural flow graph is a control flow visualization at procedure/trigger level, see procedural flow.

The visualization shows inbound or outbound flows to/from, respectively, a node in the procedural flow graph.

Click the little triangle/graph on the immediate insights line or use the context menu to view the outbound procedural flow graph for a node. Use Shift-click to view the inbound graph.

The window allow you to zoom and pan and nodes can be dragged if you want to organize nodes differently.

Node context menu:

This window gives a per table overview of RIMD operations reachable (through procedural flow) from the original procedure or trigger.

Invoke this feature from the context menu on immediate insights.

Table context menu:

Free text search can be initiated via the menu or by shortcuts (Ctrl-F for searching current object and Ctrl-Shift-F for searching all objects). The search is line by line and allows the substring with wildcards syntax.

In the following example we search for captions that start with the text ledger entry:

The search event publishers window is available through the menu of the Workspace window. Use this window to search for event publishers (integration and business):

The search fields window is available through the menu of the Workspace window. Use this window to search fields by name:

The search procedures window is available through the menu of the Workspace window. Use this window to search procedures (including event publishers and subscribers) by name:

Explore table relations is invoked from the Object context menu.

The basic idea is simple: the selected table is opened and shown with all inbound and outbound table relations. The selected table is then "fully explored" in the 1st degree connections. However the related tables may themselves have further, yet unexplored table relations:

Notice that nodes are draggable with the mouse. However, wait with fine-tuning layout positioning, as whenever a new table is added or removed from the diagram, it it is redrawn with the selected layout algorithm.

Edge context menu:

Node context menu:

Selected nodes context menu:

The transfer fields mapping is available from Object view and Extended view when TransferFields has two different tables for source and target. Invoke by using the context menuy on TransferFields.

Alternatively, this window can be opened via the object context menu (enabled for tables, only).

Use this window to see how fields are mapped. The mapping includes fields from all extensions that are part of the workspace. The mapping is sorted by field number, as this what the mapping is based on (not the field name).

The following is a mapping of TransferFields(TimeSheetDetail) in table 5510 "Employee Time Reg Buffer":

Enter or paste in a prism path to navigate to the path in the current workspace.

The file explorer is available from the "File | Explore" menu. Use the file explorer to understand which files make up the workspace.

File context menu:

AL object context menu:

If Prism cannot parse (or index) a compilation unit for some reason, this is indicated in the Workspace window once the workspace has been loaded:

Here is what the Compilation unit errors windows looks like:

If Prism encounters errors generating a code graph for some objects, this is indicated in the Workspace window once code graph generation has finished:

Here is what the Graph diagnostics windows looks like:

Prism for AL Connector is our Visual Studio Code extension that allows you to navigate to Prism for AL from any line of code in Visual Studio Code.

Prism for AL Connector is available on Visual Studio Marketplace. Install from the Marketplace or directly from Visual Studio Code (search for extension prism-al).

The extension has a single configuration, Prism for AL exe file. Leave this setting blank if you have installed Prism for AL in the default location.

In Visual Studio Code, from any cursor position of an object in an .al file, right-click and select View in Prism for AL. This will:

1. Start Prism for AL (if not already running)
2. Open the folder or workspace in Prism for AL (if not already open)
3. Navigate to the object and position closest to the cursor in Visual Studio Code

The command-line executable, StaticalPrismCmd.exe is registered as a so-called execution alias by the MSIX installer, so by magic, if you type StaticalPrismCmd.exe in a command shell you will get the correct MSIX installed version regardless of the PATH environment variable.

For help, run StaticalPrismCmd.exe -h. You can also get help on the specific command like the report command: StaticalPrismCmd.exe -h report. Furthermore, you can get help on a specific report: StaticalPrismCmd.exe report onprem-usages -h.

You can specify a workspace as either a directory or a .code-workspace file.

When integrating a report into a Continuous Integration pipeline, consider using options --log-file and --strict.

Analyzes a workspace and produces a tab-separated cross-reference of object dependencies with dependency types. Use StaticalPrismCmd.exe -h report object-dependencies for available options.

Example: StaticalPrismCmd.exe report object-dependencies "C:\workspace\LearnPrism" -o "c:\tmp\object-dependencies.csv"

Analyzes a workspace and produces a tab-separated list of unreferenced objects. Use StaticalPrismCmd.exe -h report unreferenced-objects for available options.

Example: StaticalPrismCmd.exe report unreferenced-objects "C:\workspace\LearnPrism" -o "c:\reports\learn\object-dependencies.csv"

Analyzes a workspace, builds a code graph and produces a tab-separated list of references to procedures and objects that are OnPrem annotated. Use StaticalPrismCmd.exe -h report onprem-usages for available options.

Example: StaticalPrismCmd.exe report unreferenced-objects "C:\workspace\LearnPrism" -o "c:\reports\learn\onprem-usages.csv --log-file c:\tmp\onprem-usages.log --strict"

Opens the Prism for AL application on a workspace. If Prism for AL is already running, no new instance is used, If the workspace is already open, then it is not reopened. Use StaticalPrismCmd.exe -h open for all available options.

Example: StaticalPrismCmd.exe open "C:\workspace\LearnPrism"

Symptom: Solution shows unexpected unresolved modules:

The tooltip gives a hint to the reason. In this case, the Base Application and System packages are unavailable because they have not been downloaded from Visual Studio Code, so use the Visual Studio Command AL: Download symbols, then reload the workspace.

Click on a line to view details such as which dependencies made Prism for AL want to resolve this module.

We can help trouble-shoot the issue for. Please refer to the Trobleshoot menu in the control panel window and email us the .wrec file.

Symptom: You opened a folder which is not a Visual Studio Code project folder, i.e. a folder with no app.json file directly in the folder, and the module is not listed in the Solution's General tab.

The cause is likely that the package is a runtime package. To verify this, check the Discovery tab:

Prism for AL cannot load runtime packages as they are encrypted, so the only remedy for this issue is to use a normal (not runtime) package, if possible.

Symptom: Solution shows a package with no objects, but you know the package contains objects:

This is perfectly normal for dependency-propagation-only modules such as Application. If this happens for other packages that you know contain objects, then it is most likely because the package is a runtime package. When you use AL: Download symbols, then Visual Studio Code will download an .app file with symbol file with no objects. There is currently no way to decude that the downloaded .app file is a runtime package so Prism shows this as a package without objects. The only remedy for this issue is to publish a normal (not runtime) package.

Symptoms: The workspace window indicates compilation unit errors.

If a workspace compiles with the AL compiler in Visual Studio Code, Prism for AL should be able to parse and analyze it. To diagnose, do the following:

1. Use AL: package to run the AL compiler in Visual Studio Code; if that fails, fix the error and reload the workspace.
2. If you have changes workspace files in Visual Studio Code (or another tool), please reload the workspace.
3. If the steps above do not explain or fix the issue, then please report a bug via the Feedback window or email us at feedback@stati-cal.com. See compilation unit errors for how to get the error details that you can include in your description.

Symptoms: The workspace window indicates graph errors.

If you encounter any graph errors, please report a bug via the Feedback window or email us at feedback@stati-cal.com. See graph errors for how to get the error details that you can include in your description.

Symptom: Navigation internally in Prism for AL or from Visual Studio Code to Prism for AL is inaccurate.

This can happen if you had Memory cache unchecked when you loaded the workspace and workspace files have changed since then. In this case the solution is to reload the workspace.

If you experience the symptom in other situations, please report a bug via the Feedback window or email us at feedback@stati-cal.com.

Symptom: The Control panel license heading is 'Community Edition', the license status indicates an error (red text, e.g. 'invalid' or 'expired') and the message in the lower part of the control panel also indicates an issue:

For details about the error, check out the tooltip on the license status as indicated in the screenshot above.

When the license is not valid, Prism for AL runs in a feature-limited mode until you paste in a valid license key.

If you have just entered the license, most likely you have not copied the whole license key, by accident copied an old key, or the license key is for Prism for C/AL instead of Prism for AL.

If the license has expired, please contact your license administrator.