IFX 2026 debugger cannot display array variables in Visual Studio 2026

[MartiBayer]

Hi,

I recently migrated from Visual Studio 2019 Community to Visual Studio 2026 Professional and am now compiling with Intel® Fortran Compiler (IFX) 2026.0.0.

The code runs correctly, but I have a debugger issue.

Environment

• Visual Studio 2026 Professional (18.7.3)
• Intel Fortran Compiler 2026.0.0 (IFX)
• x64 Debug configuration
• Windows 11

Problem

In Visual Studio 2019 I could inspect array variables in the debugger and see all elements.

With IFX 2026, some arrays cannot be displayed in either the Watch or Locals windows.

Example:

SUBROUTINE SET_WELL_FILE_AND_RUNMODFLOW(...)

   IMPLICIT NONE

   INTEGER :: NSIMS,NREM_WELLS

  INTEGER :: REM_WELL_CELL(NSIMS,NREM_WELLS)

  REAL    :: REM_WELL_RATE(NSIMS,NREM_WELLS)

   ...

   CELL = REM_WELL_CELL(SIM,I)

  RATE = REM_WELL_RATE(SIM,I)

 END SUBROUTINE

When stopped at a breakpoint:

• Scalars are displayed correctly:

RATE

SIM

I

• However:

REM_WELL_CELL

REM_WELL_RATE

 

cannot be displayed.

In the Watch window I get:

identifier "REM_WELL_CELL" is undefined

identifier "REM_WELL_RATE" is undefined

In the Locals window I get:

An unspecified error has occurred.

Additional tests

I created a local fixed-size array:

REAL :: TEST(5)

TEST = (/1.0,2.0,3.0,4.0,5.0/)

The debugger displays TEST correctly.

I also created local copies:

INTEGER :: CELL_COPY(NSIMS,NREM_WELLS)

REAL    :: RATE_COPY(NSIMS,NREM_WELLS)

CELL_COPY = REM_WELL_CELL

RATE_COPY = REM_WELL_RATE

But the debugger still reports: An unspecified error has occurred.

for CELL_COPY and RATE_COPY.

Interestingly, the Locals window shows metadata such as:

CELL_COPY$1superbound

CELL_COPY$2superbound

REM_WELL_CELL$1superbound

REM_WELL_CELL$2superbound

so the debugger appears to know the array dimensions, but not the contents.

Question

Is this a known IFX 2026 debugger limitation/bug related to:

• adjustable arrays with runtime bounds?
• local automatic arrays?
• Visual Studio 2026 integration?

Has anyone found a workaround that allows array contents to be inspected in the debugger?

Thanks.

[henry_collins]

Yes, this looks like a known limitation or regression with IFX + VS 2026 debug visualization for assumed or automatic arrays. The fact that scalars show fine and the $superbound metadata appears means the debugger is seeing the symbol info, but failing to materialize the runtime buffer for dynamic-shaped locals.

A few people have hit this specifically with adjustable or automatic arrays especially in x64 Debug with IFX 2026.

Workarounds that usually help:

• Try compiling with -Od -g plus disabling optimization completely (IFX sometimes still “partially optimizes” array storage).

• Temporarily convert to explicit-shape allocatable arrays:

INTEGER, ALLOCATABLE :: REM_WELL_CELL(:,:)

• Or copy into a fixed-size debug buffer (what you already tried, but ensure it’s not optimized away, use VOLATILE on the source dest).
• In some cases, switching debug format to /debug:full  improves watch evaluation.

Also worth noting: VS Watch window often fails with IFX unless the array has fully resolvable bounds at compile time, so this may be more of a debug info + VS natvis gap than your code.

[MartiBayer]

thanks a lot for your answer, this is the optimization sertting I have now: 

to compile with -Od -g as you suggest, do I have to add this in the "command line" below?? thanks again!!!

[DonRobinsonESSA]

This might be due to a problem with the Fortran Expression Evaluator. Check under the Extensions tab and see if this is extension installed. You may need to Uninstall then re-install. This resulted in much better resolution of variables for me and resolved many of the error messages you're seeing. 

[MartiBayer]

Thank you for your answer, I guess what I need is this: 

will open a ticket to see if I can get it installed (do not have admin rights and need to installe everything through ITs)!

Let's see if it works!! Thanks a lot!

[MartiBayer]

I installed Fortran Expression Evaluator and this solved the problem.

Thanks a lot henry_collins and DonRobinsonESSA!!

[herman34]

It is a debugger issue than a problem with your code. The fact that scalar values display correctly and fixed size arrays work, while automatic arrays with runtime dimensions do not, suggests the debugger is struggling to evaluate those array types rather than the arrays being invalid. As the debugger can already see entries like REM_WELL_CELL$1superbound, it seems to recognize the array descriptor but fails when trying to access the actual data. So consider this a bug or limitation in the IFX 2026 + Visual Studio 2026 debugger integration. As a workaround, you could try allocating the arrays dynamically (ALLOCATABLE) instead of using automatic arrays, or check whether the same project behaves correctly  with the latest oneAPI/IFX update if one is available.

This is my opinion1

[henry_collins]

This sounds more like an IFX 2026/Visual Studio debugger integration issue than a problem with the arrays themselves. The fact that fixed-size local arrays work and the debugger exposes the $superbound metadata suggests it can see the descriptors but is failing to evaluate the runtime bounds/data. Try the latest available IFX/VS update first, and if the issue persists, report it to Intel with a minimal reproducer. As a temporary workaround, copying individual elements into scalar locals may be the easiest way to inspect values.