Intel® Fortran Compiler Release Notes and System requirements

The Intel® Fortran Compiler (ifx) is based on the Intel Fortran frontend and runtime libraries but uses modern LLVM-based backend compiler technology. Because of this, ifx gives you all the Fortran features you know in Intel Fortran, like legacy DEC extensions, superior Fortran Standards support, and powerful compiler directives. Everything you expect in Intel Fortran. But, in addition, ifx adds new capabilities for Intel’s latest CPU and GPU products, including OpenMP TARGET and automatic DO CONCURRENT offload to Intel GPUs for additional accelerated performance.

ifx fully supports Fortran Standards through Fortran 2018 and now includes several Fortran 2023 features.

Where to Find the Release

You can get the latest version of Intel® Fortran Compiler (ifx) as part of the Intel® oneAPI Toolkit, or as a Stand-Alone download.

If you have Priority Support for Intel® oneAPI Toolkit or any other oneAPI toolkit (i.e. an unexpired free license or a paid license with active support at the time of the build date for this product release), you can download the installer by logging in to Intel® Registration Center and selecting the appropriate product. You may need to create an account and/or register your product. For additional information, please see: Product Registration and Sign-Up FAQ

New in this Release

New in ifx 2026.0 release

New Fortran features in this release:

• The leading zero edit mode allows a user to control the output of optional leading zeros in numeric outputs.  The default may be set when a file is opened, and overridden by the LEADING_ZERO= specifier in the control list of a WRITE statement, or controlled by the LZ, LZP, and LZS format edit descriptors.
• The NOTIFY= specifier in an image selector increments a NOTIFY_TYPE variable on the remote image that data is written to.  The NOTIFY WAIT statement waits until the NOTIFY_TYPE variable specified reaches a the threshold value specified before the image continues execution.  This is a more efficient mechanism that a EVENT POST following a remote write statement.  NOTIFY WAIT is an execution control statement, but not an image control statement, so syncing memory across images is not required.
• Conditional expressions provide for the evaluation of a selected subexpression.  Logical expressions are evaluated from left to right until the first expression that evaluates to true is found, and the corresponding subexpression is evaluated and becomes the value of the expression.  If no true logical expression is found, the default subexpression becomes the value of the conditional expression.  The syntax is the same as that for C conditional expressions: 
  (scalar_logical_expr ? expr [: scalar_logical_expr ? expr] … : expr). 

New OpenMP features in this release:

• The OpenMP 6.0 PREFER_TYPE modify syntax for an interop object allows specification of foreign runtime identifiers and attributes.
• The OpenMP 6.0 THREADSET clause allows users to specify the set of threads that execute tasks generated by TASK and TASKLOOP constructs.
• The OpenMP 6.0 AUTOMAP modifier on the ENTER clause of a DECLARE TARGET directive automatically maps allocated ALLOCATABLE data objects to a device and removes deallocated ALLOCATABLE data objects from the device.
• The -qopenmp-threadprivate option allows you to specify an OpenMP* threadprivate implementation.

Changes in this release:

• Starting from Intel® Fortran Compiler version 2025.3, the Microsoft Visual Studio* Intel® Fortran Expression Evaluator (FEE) is not part of the Intel® oneAPI Toolkit anymore. You need to install the Intel® Fortran Expression Evaluator (FEE)  extension manually from VS Extensions to enable all Fortran application debugging features. 

• Microsoft Visual Studio* 2026 support is available in the Fortran IDE extension. This feature was introduced in the 2025.3.1 patch release and is included in the 2026.0.0 release. Users can continue to use existing workflows without any changes. Supported on Windows 10 and 11.

Known Issues and Limitations  

BLOCK DATA

• On Windows systems, a subprogram built into a library that references a common block variable initialized in a BLOCK DATA subprogram that is compiled separately and linked with the library will not get initialized, but will have a zero value.  The workaround for this problem is to compile the subprogram and the BLOCK DATA subprogram together, or pass the object file with BLOCK DATA separately on the link line.

COMMON Block

• Beginning with the Intel® Fortran Compiler (ifx) version 2023.2.0, programs that declare a COMMON block, instead of individual COMMON block variables, in an OpenMP data sharing clause cause a runtime failure, i.e., segmentation fault or incorrect result. The workaround is to declare the individual COMMON block variables.

Integration with Microsoft Visual Studio*

• On systems where the Intel® Fortran Compiler 2025 (IFX) is installed without a previous version of IFORT, users might encounter an error when building a Fortran project in Microsoft Visual Studio*: "The Fortran compiler (ifort.exe) cannot be found."
• To resolve this, right-click on the project in Solution Explorer, select "Intel Compiler," and then choose "IFX Intel Fortran Compiler."

map-type/map-type-modifier

program main                        
   type mytype                      
      integer, pointer :: p(:)      
      integer :: y                  
   end type                         
                                    
   type(mytype) :: x                
   x%p => null()                    
   x%y = 111                        
#if BUG                             
   !$omp target map(to: x)          
#else               
   !Workaround                
   !$omp target map(to: x, x%p)     
#endif                              
   print *, associated(x%p) ! not ok
   print *, rank(x%p) ! not ok      
   print *, x%y ! ok                
   !$omp end target                 
end        

map-type/map-type-modifier applied to it is not propagated to the pointer component of the derived type. This means that if "x" is mapped with map(to), the pointer component is not mapped with "map(to)" but only with "map(alloc)". The result is that any query regarding the association status, rank, etc, on the pointer x%p done on its device copy, will return random results.

The above behavior complies with the spec requirement "If a pointer field of a derived type is not explicitly mapped, the pointer is attach-ineligible."
The proper approach is to explicitly map the pointer when mapping the pointer x%p on the same construct, as shown above.

Fortran Coarray Application Hangs After Executing FAIL IMAGE

If you use a FAIL IMAGE statement to make an image fail, you should use a STAT= specifier or a STAT argument in all coarray operations that might encounter that failed image if the statement or operation permits, or you should specify either the assume failed_images or standard-semantics compiler option. If you do not use a STAT= specifier, a STAT argument, or specify one of the compiler options, those operations will not check for failed images. They may then try to coordinate with the failed image, waiting for a response from it. The response would never happen and so the application would hang.

The following example demonstrates using the STAT= specifier to prevent an application hang.

SUBROUTINE FAIL_AND_SYNC ( THIS_ONE )
   INTEGER THIS_ONE
   INTEGER MY_STAT
   IF (THIS_IMAGE() .EQ. THIS_ONE) THEN
       FAIL IMAGE
   END IF
   SYNC ALL (STAT=MY_STAT)      ! Would hang without STAT=
END SUBROUTINE FAIL_AND_SYNC

opt-reports

There is a known issue with using opt-reports with programs containing OpenMP loop constructs with "schedule(dynamic)", which may cause the compiler to emit an error. In this case, it is recommended that the user remove -qopt-report from their compilation.

Potential for Incorrect Results Using Certain OpenMP Offload Directives

There is potential for incorrect results using OpenMP pragmas to offload to Intel® GPUs where a parallel loop nested inside a TEAM construct is using a variable in a REDUCTION clause, and the TEAM construct does not have the same REDUCTION clause. To avoid incorrect results, compile with -mllvm -vpo-paropt-atomic-free-reduction-slm=true to disable global memory buffers.

Using -ipo and mixing ifx with ifort object files.

ifx is binary (.o/.obj) and module (.mod) file compatible; binaries and libraries generated with ifort can be linked with binaries and libraries built with ifx, and .mod files generated with one compiler can be used by the other (64-bit targets only). If you compile with -ipo though, the compatibility between ifort and ifx is broken. 

GPU Driver Hanging Issue

If you have applications with long-running GPU compute workloads in native environments, you must disable the hangcheck timeout period to avoid terminating workloads. For more information, see the Installation Guide for your OS.

OpenMP offloading to Intel® Xe-LPG Integrated Graphics GPUs

Fortran applications that perform OpenMP offloading to Intel® Xe-LPG Integrated Graphics GPUs may encounter runtime failures or unexpected results. This error has been seen on The latest Intel® Core™ Ultra processors (Series 1 and Series 2), codenames Meteor Lake and Lunar Lake. Affected applications use OpenMP DISTRIBUTE PARALLEL DO constructs with collapse clause added inside an OpenMP target region. The issue has been isolated to the current GPU drivers for Intel® Core™ Ultra processors (Series 1 and Series 2), codenames Meteor Lake and Lunar Lake. A driver update to address this issue will be released at a future date.

Device pointer translation issue 

If the pointer translation for xptr listed in the "adjust_args(need_device_ptr: xptr)" clause fails, the expected behavior according to the OpenMP specifications is to nullify xptr, but the current ifx behavior is to use the untranslated host pointer. 

CMake Information

• Starting from CMake 3.25, due to limitations in the way CMake tracks linker flags, a CMake project with mixed C/C++ and Fortran code where one of the compilers is LLVM-based (e.g. icx, ifx) and another is the classic version (e.g. icc, ifort) will result in invalid linking flags. As an example, CMake cannot build a project using "icx" as the C/C++ compiler and "ifort" as the Fortran compiler.
  • The workaround is to use only LLVM-based compilers when building mixed-language applications. 
• Starting from CMake 3.27, CMake support for Intel® oneAPI DPC++/C++ Compiler and Intel® Fortran Compiler has been updated to use the compiler driver instead of the linker for linking. This change enables use cases for building SYCL applications and libraries and enables Interprocedural Optimization (IPO) on Windows*. 

Some old dependencies failed with Configure Script Reports: "linking to Fortran libraries from C fails."

Symptom:

When compiling with ifx, a ./configure script generated by GNU Autconf reports an error message similar to:

    checking for Fortran 77 libraries of ifx...  -loopopt=0 -L/lib/../lib64 -L/lib/../lib64/ -L/usr/lib/../lib64 -L/usr/lib/../lib64/ -L/lib64 -L/lib/ -L/usr/lib64 -L/usr/lib -lifport -lifcoremt -limf -lsvml -lm -lipgo -lirc -lpthread -lirc_s -ldl
    configure: WARNING: FLIBS does not work
    checking for ifx flag to add single underscore to external names... none
    checking for dummy main to link with Fortran 77 libraries... unknown
    configure: error: in '/path/to/build/dir':
    configure: error: linking to Fortran libraries from C fails
    See `config.log' for more details
    make: *** [build/config.status] Error 1

Examining the config.log file shows that the error causing ./configure to exit was:

    ld: cannot find -loopopt=0

Root-cause: 

In trying to determine libraries needed to link Fortran code with C or C++ code, GNU Autoconf 2.69 and earlier mistakenly interprets -loopopt=0 in -mllvm -loopopt=0 in verbose compiler output as a linker flag.  GNU Autoconf then adds -loopopt=0 to the FLIBS variable, which is passed to the linker.  The linker then looks for a non-existent library, causing the test to fail.

Solution for Users Downloading Source Code:

Please inform the maintainers of packages impacted by this error about the problem and refer them to this release note. Projects vary in how they handle configure scripts; however, some general rules apply. Users who need a solution before the package maintainer can respond can update the configure script themselves. The difficulty of updating depends on how the package is distributed.

To update, first, install GNU Autoconf-2.70 or newer, as described in Solution for Package Maintainers, below.

After installing the updated autoconf in the user's path, packages that distribute the configure.ac file along with the configure  script can be updated simply by running:

    autoreconf -if

The resulting configure script should be completed without the above error in FLIBS.

It is not uncommon for project maintainers to remove the configure.ac file from a source distribution in a tar or zip archive.  In that case, the user usually needs to download the project from its code repository and build according to the project's instructions.  Sometimes a version of the configure script is committed to version control and not automatically regenerated.  In that case, either running autoreconf -if as described above, or deleting the configure script often triggers it to be regenerated.  Ideally, the project documentation will describe how to rebuild the configure script.

Solution for Package Maintainers:

To prevent users from seeing errors, update to GNU Autoconf to version 2.70 or later and re-generate the project configure script.  GNU Autoconf-2.70 was released on December 8, 2020.  The source code is available via git clone: http://git.sv.gnu.org/r/autoconf.git.  GNU Autoconf documentation is available through the GNU Autoconf Project Page.

System Requirements

Supported Architectures and Terminology - Intel® 64 Architecture refers to systems based on IA-32 architecture processors, which have 64-bit architectural extensions (like Intel® Core™ architecture processors, running a 64-bit operating system such as Microsoft Windows* 10 x64 or a Linux* "x86_64" variant).

Note: Minor releases (e.g., 2026.1) automatically inherit all OS requirements from the base major release (2026.0). Only operating systems marked with (+) are newly added in that minor release, and those marked with (–) are removed. Asterisks(**) indicates Deprecations. All others remain unchanged and are not duplicated in the table.

Hardware Requirements

Supported Operating Systems

• Note: These OS distributions are tested by Intel or known to work; other distributions may or may not work and are not recommended. If you have questions, access the Intel Community Forums when you need assistance.  If you have Commercial Support, create a support ticket.

Supported IDEs

Eclipse*

• Eclipse 2025-12
• Eclipse 2025-09
• Eclipse 2025-06

Microsoft Visual Studio*

• Microsoft Visual Studio* 2022 17.x with 'Desktop development with C++' component installed
• Microsoft Visual Studio* 2026 18.x with 'Desktop development with C++' component installed

Software Requirements

• Linux kernel 4.11 or higher
• Supported minimum versions of distributed libraries that the compilers are built on: GCC - 7.5.0, BINUTILS- 2.30, GLIBC-2.28, G++ - 7.5.0.  If the highest version of GNU GCC used doesn't have the equivalent g++ package installed, the customer will run into an error. For further details, please check this article--fatal error: <C++ header> file not found with Intel® oneAPI DPC++/C++ Compiler

For GPU: Level 0 and OpenCL  graphics drivers

• To install the Linux General Purpose Intel GPUs (GPGPU) Driver, see the installation guide and follow the directions for your device.

• You must have the latest drivers to collect GPU usage events and processor graphics hardware events on Windows*. Request drivers from Intel® Support or download them here.

• Requirements to compile DPC++ applications: You must compile DPC++ applications with -gline-tables-only and -fdebug-info-for-profiling options to ensure the availability of debug information for performance analysis.

Graphics Driver Installation

• Windows Intel® Graphics Driver
  To install the driver, follow the directions in the article appropriate for your device

  • Intel® Arc™ Graphics, 11th-13th Gen Intel® Core™ processor directions.
  • Xe Dedicated, 6th-10th Gen Intel® Core™ Processor Graphics, and related Intel Atom®, Pentium®, and Celeron® processors directions. Driver version varies depending on the Intel® Graphics in the system.
  • Intel® Data Center GPU Flex Series (ATS-M). Contact your OEM representative for access to the Intel® Registration Center.
• Linux General Purpose Intel® GPUs (GPGPU) Driver
  For all Intel® GPUs, see this article, Overview, and follow the directions for your device.

Support Deprecated

Lists the features or tools which will be deprecated, along with date and timeline of deprecation

Support Removed 

• The Intel OpenMP extension SUBDEVICE clause on TARGET, TARGET DATA, TARGET ENTER DATA, TARGET EXIT DATA, and TARGET UPDATE constructs is no longer supported. 
• The Intel proprietary syntax for “omp target variant dispatch” to call MKL functions that offload to a GPU is no longer supported. It can be replaced by "omp target dispatch".

• Support of the Fortran IDE extension for Microsoft Visual Studio* 2019 has been discontinued starting from the 2026.0.0 release. Users are recommended to upgrade to a supported Microsoft Visual Studio* version (Microsoft Visual Studio* 2022 or later) to continue using the Fortran IDE extension.

Other Documentation and Support

Product documentation is available online

• Intel® Fortran Compiler Classic and Intel® Fortran Compiler Developer Guide and Reference
• Read this supplemental article for more information about ifx and its implementation of the Fortran and OpenMP standards.
• Porting Guide for ifort Users to ifx
• OneAPI Versioning Schema based on Semantic Versioning
• Intel® oneAPI Toolkits Installation Guide
• Get Started with the Intel^® oneAPI Toolkits for Linux*
• Get Started with the Intel^® oneAPI Toolkits for Windows*

• Get Started with OpenMP* Offload to GPU for the Intel® oneAPI DPC/C++ Compiler and Intel® Fortran Compiler

Directory Layout Change Implemented in 2024.0

The directory layout is improved across all products to streamline installation and setup. The Unified Directory Layout is implemented in 2024.0. If you have multiple toolkit versions installed, the Unified layout ensures that your development environment contains the correct component versions for each installed version of the toolkit. The directory layout used before 2024.0, the Component Directory Layout, is still supported on new and existing installations. For detailed information about the Unified layout, including how to initialize the environment and its advantages, refer to Use the setvars and oneapi-vars Scripts with Linux and Use the setvars and oneapi-vars Scripts with Windows.

Technical Support

If you have Priority Support, create a support ticket. Otherwise, access the Intel^® Fortran Compiler forum when you need assistance. 

Legal Information

No license (express or implied, by estoppel or otherwise) to any intellectual property rights is granted by this document.

Intel disclaims all express and implied warranties, including without limitation, the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, as well as any warranty arising from course of performance, course of dealing, or usage in trade.

This document contains information on products, services and/or processes in development. All information provided here is subject to change without notice. Contact your Intel representative to obtain the latest forecast, schedule, specifications and roadmaps.

The products and services described may contain defects or errors which may cause deviations from published specifications. Current characterized errata are available on request. No product or component can be absolutely secure.

Copies of documents which have an order number and are referenced in this document may be obtained by calling 1-800-548-4725 or by visiting Resource & Documentation Center.

Intel, the Intel logo, Intel Core, Intel Xeon Phi, VTune, and Xeon are trademarks of Intel Corporation in the U.S. and/or other countries.

*Other names and brands may be claimed as the property of others.

Microsoft, Windows, and the Windows logo are trademarks, or registered trademarks of Microsoft Corporation in the United States and/or other countries.

Java is a registered trademark of Oracle and/or its affiliates.

OpenCL and the OpenCL logo are trademarks of Apple Inc. used by permission by Khronos.

Copyright 2010 - 2022 Intel Corporation.

This software and the related documents are Intel copyrighted materials, and your use of them is governed by the express license under which they were provided to you (License). Unless the License provides otherwise, you may not use, modify, copy, publish, distribute, disclose or transmit this software or the related documents without Intel's prior written permission.

This software and the related documents are provided as is, with no express or implied warranties, other than those that are expressly stated in the License.