Fortran-lang

Mentors: Student: HarshilShah

This proposal aims to improve LFortran by compiling and validating real-world Fortran packages such as M_intrinsics, fman, and gtk-fortran. Instead of focusing on isolated features, it follows a compilation-driven approach to identify and resolve limitations across different stages of the compiler, including parsing, semantic analysis, code generation, and runtime support. Key issues such as incomplete I/O specifier handling, quadruple precision support, and array constructor transformations will be addressed. The project emphasizes iterative development, testing, and validation against reference compilers, with the goal of improving LFortran’s robustness, correctness, and support for complex, real-world applications.

Mentors: Student: Jatinagarwal24

LFortran is a modern, interactive Fortran compiler built on LLVM that aims to support real-world Fortran codebases. This project focuses on enabling full compilation and correct execution of two real-world Fortran packages benchmark.f (a benchmarking library) and feq-parse (an equation parser) using LFortran. Significant pre-GSoC progress has already been made: benchmark.f currently compiles to 76% and feq-parse to 40%. The remaining blockers include missing quadruple precision (REAL(KIND=16)) support, deserialization ICEs for forward-referenced symbol tables, ExternalSymbol resolution failures for struct-scoped types, ASR verifier false positives for GenericProcedure constructor calls, and an LLVM IR type mismatch in character length handling. The project will follow an iterative, compilation-driven workflow: attempt compilation, identify failures, reduce to MREs, fix the compiler, and validate against gfortran. Every fix will be accompanied by integration tests to prevent regressions. Deliverables: - Full compilation of both benchmark.f and feq-parse with LFortran - All example programs and test suites passing with gfortran-consistent output - End-to-end quadruple precision support across parsing, ASR, and LLVM backend - All fixes merged as pull requests with integration tests

Mentors: Student: Yash Nagda

LFortran's MLIR(Multi-Level Intermediate Representation) backend executes fortran code via LLVM dialect of MLIR, but requires major refactoring with every new MLIR version. This is because it calls unstable MLIR C++ APIs directly, which gets changed with MLIR version changes. This project focuses on finding the right design to solve this problem. Multiple approaches will be studied and compared including studying projects which support MLIR to identify the most stable and maintainable architecture. The best design will then be implemented and validated. The deliverable is a redesigned MLIR backend that is stable across MLIR versions, requiring minimal refactoring for adding support for newer versions in future.

Mentors: Student: Jainam_29

This project aims to implement full coarray support in the LFortran compiler, enabling native parallel programming capabilities based on the Partitioned Global Address Space (PGAS) model defined in the Fortran 2008/2018 standards. Currently, while LFortran’s parser supports coarray syntax, the feature is not implemented beyond basic stubs, preventing execution of even minimal coarray programs. The project will bridge this gap by extending LFortran’s Abstract Semantic Representation (ASR) to model coarrays, implementing semantic analysis for coarray constructs, and introducing a dedicated coarray runtime library. A key component is an ASR-to-ASR lowering pass that translates high-level coarray operations (such as coindexed access, synchronization, and collective intrinsics) into runtime calls. This design follows LFortran’s existing OpenMP architecture, ensuring backend-agnostic support across LLVM, C, and other targets. The implementation will proceed in two phases: first, establishing a fully functional single-image mode with correct semantics and runtime integration; second, enabling multi-image execution using an MPI-based runtime backend. By the end of the project, LFortran will be capable of compiling and executing coarray programs in both single-node and distributed environments. This work lays the foundation for supporting real-world coarray-based HPC applications and positions LFortran as a leading LLVM-based Fortran compiler with modern parallel programming support.

Mentors: Student: Jinang Shah

In order to make LFortran reach beta quality, it is essential to compile more benchmarked fortran codes. FPM(Fortran Package Manager) is one of the best example of such codebase. Successfully compiling FPM will make LFortran a more robust compiler and it will be a huge boost for LFortran to reach at beta quality. For this year's GSOC project, I am planing to compile FPM with LFortran. Since FPM depends on other 5 open source fortran codebases (toml-f, fortran-regex, fortran-shlex, M_CLI2, jonquil) , my plan is to compile those 5 small codebases till 1st month of coding period. To compile any code, my idea is to create workarounds that compile with LFortran till code compiles fully with LFortran, then create MREs for each workarounds and finally fix them and remove workarounds from original code. This way I will compile in order: toml-f, fortran-regex, fortran-shlex, M_CLI2, jonquil so that all dependencies are solved well. After completing these 5 codes, I will follow same process to compile FPM. Detailed weekly plan is discussed in my proposal. Deliverables: Compile toml-f, fortran-regex, fortran-shlex, M_CLI2, jonquil, FPM completely with LFortran.