-
Notifications
You must be signed in to change notification settings - Fork 171
GSoC 2023 Ideas
Below we list developed project ideas listed by priority. The "High Priority" section contains projects that we are especially interested in, as they lie on the critical path to a minimal viable product: make LPython usable for simpler projects.
However, feel free to propose any project idea that you like to improve LPython, for example by browsing open issues:
https://github.com/lcompilers/lpython/issues
If you are interested in applying, please get in touch with us at either our Zulip chat or our mailing list:
- https://lfortran.zulipchat.com (LPython channel)
- https://groups.io/g/lfortran
We will help answer questions and help with finding and refining a project idea. You do not need to have prior experience with compilers, we will teach you. It is fun. LPython is written in C++, but we do not use many advanced features and if you have any programming experience you will be able to pick it up.
Here are a few projects for inspiration, they contain a mix of well-developed ideas and less developed ideas. You are welcome to propose your own idea as well.
We have a patch requirement in order to consider your application. Please send a patch (Pull Request) to LPython that has to be merged by the time the application period closes (April 19). You can fix or improve anything you like. If you have any questions, please contact us (for example on Zulip) and we will help.
Potential mentors:
- Ondřej Čertík
- Gagandeep Singh
- Rohit Goswami
- Thirumalai Shaktivel
- Smit Lunagariya
- Luthfan Lubis
LPython has initial generics implemented, they allow to write functions that accept generic arguments and are instantiated at the call site using the actual types provided by the user. In this project we will extend it to many more cases and implement enough features so that we can implement the standard library and NumPy using generics.
Expected outcomes: LPython can compile untyped code using generics.
Skills preferred: Python and C++ programming
Difficulty: intermediate, 350 hours
Mentors - Ondřej Čertík, Rohit Goswami, Gagandeep Singh, Luthfan Lubis
The roadmap https://github.com/lcompilers/lpython/issues/155 issue contains a list of Python features that we want implemented. Each feature should be implemented at the ASR level and in the LLVM backend to be complete. If AST is missing for a given feature, then it has to be implemented also.
Here you can pick a feature or a set of features from the list and propose it as a GSoC project. In other words, this project idea can accommodate multiple student projects.
List of resources for more information and background:
- ASR.asdl, the comment at the top explains the design motivation
- asr_to_llvm.cpp is the LLVM backend
- ast_to_asr.cpp is the AST -> ASR conversion where all semantics checks are being done and compiler errors reported to the user
- Developer Tutorial
If you have any questions, please do not hesitate to ask, we can discuss or provide more details.
Difficulty: easy/intermediate (depending on the task), can be 175 hours or 350 hours
Mentors: Ondrej Certik (@certik), Gagandeep Singh
This project would entail working with LPython, LLVM, Emscripten, and Webassembly to allow running LPython in the browser.
- use LLVM and Emscripten to compile LPython code to Webassembly
- create custom Webassembly backend for LPython and compile LPython itself to Webassembly
Relevant issues:
- https://gitlab.com/lfortran/lfortran/-/issues/583
- https://gitlab.com/lfortran/lfortran/-/merge_requests/1549
- https://gitlab.com/lfortran/lfortran/-/merge_requests/1385
Expected outcomes: LPython can compile Python code, as well as bootstrap itself, to Weabassembly.
Skills preferred: Python and C++ programming
Difficulty: intermediate, 350 hours
Mentors - Ondřej Čertík, Rohit Goswami
This project would be used to first serialize the ASR and then use it within a language server.
Expected outcomes: LPython can be used as a Python language server that can be used in other software such as source code editors and IDEs.
Skills preferred: Python and C++ programming
Difficulty: intermediate, 350 hours
Mentors: Ondřej Čertík (@certik), Smit Lunagariya
The Python standard library has a lot of modules: https://docs.python.org/3/library/index.html.
The project includes discussing which modules will be needed for LPython (from a scientific computing perspective, in the beginning), creating a priority list, and then implementing each module properly. The aim of this project is to make LPython work for any Python code down the road.
See #200 as a related issue. Feel free to discuss the details with us.
Skills preferred: Python and C++ programming
Difficulty: intermediate, 350 hours
Mentors: Ondřej Čertík (@certik), Naman Gera, Smit Lunagariya
LPython has a very fast WASM backend that can translate large parts of ASR to WASM. This project would work on making the WASM work for all of ASR, by adding tests and implementing missing features. As every backend in LPython, the backend receives the code as ASR, and it recursively walks over each ASR node and generates WASM code.
Mentors: Ondrej Certik (@certik), Gagandeep Singh, Ubaid Shaikh
Difficulty: intermediate, 350 hours
LPython has WASM to x86_64 code generation backend implemented which allows very fast compiling (many times faster than going via LLVM). The x86 backend does not do any optimizations, so it is meant to be used in Debug mode only. The backend recieves WASM code and creates an x86_64 ELF binary.
The purpose of this project would be to extend this backend to cover more LPython/WASM features.
If you have any questions, please do not hesitate to ask, we can discuss or provide more details.
Mentors: Ondrej Certik (@certik), Gagandeep Singh, Ubaid Shaikh
Difficulty: intermediate, 350 hours
This project would create an initial WASM to Apple M1 backend. It would work similarly to the WASM->x86 backend, but it would generate ARM code and MachO binary format that works on Apple M1.
If you have any questions, please do not hesitate to ask, we can discuss or provide more details.
Mentors: Ondrej Certik (@certik), Gagandeep Singh, Ubaid Shaikh
Difficulty: intermediate, 350 hours
Add a backend to LPython that automatically exposes (eventually all) LPython module contents to Python. That will allow using LPython compiled code to be used from CPython itself.
Related issues:
- lfortran#133: Automatic wrappers ASR -> Python
Mentors: Ondrej Certik (@certik), Rohit Goswami
Difficulty: intermediate, 350 hours