Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
<p>The Fortran offers all the ingredients needed for building modules of various data types such as linked-list, maps, binary tree, etc.<br> This project aims to enhance the already existing and continuously improving Fortran-lang, i.e. stdlib, by implementing a linked list module in it. We wish to provide a module that can be used “off the shelf” by any Fortran user. The project mainly focuses on implementing the most efficient linked list and not just a simple linked list.</p>
<p>The aim of this project would be to create a GHC plugin that allows instructors to define requirements for the code within a project and automatically validate them. This plugin would have applications for users in a broad range of educational contexts, such as university professors teaching functional programming classes using Haskell, community members writing tutorials for their libraries, and authors who are writing textbooks with exercises.</p> <p>It would offer validation of requirements from basic static analysis like whitelisting/blacklisting of standard library symbols and checks for line length and warnings through to more advanced runtime testing involving checking that functions in the given code pass specified unit tests.</p> <p>The structure of the project would be to create a domain-specific language for expressing the requirements, then to write the plugin, which would enforce the specified requirements. This would happen by injecting new code into the program to check for a specific “validation mode”, which replaces the original behaviour of the program with any necessary runtime validation, and replaces its output with a report about how well the code follows the requirements.</p>
<p>Issue-wanted is a web application focused on improving the open source Haskell community. It does so by centralizing and categorizing GitHub issues across many Haskell repositories into a single location. The current issue-wanted code base is a skeleton project with a list of desired features. Over the three month period, I will build the backend by implementing the GitHub API query functions, database schema, asynchronous worker, API endpoints, and the necessary tests. Many more decisions will be made throughout the process. This proposal covers the features and components that make up issue-wanted, and the different ways they may be implemented.</p>
<p>This proposal aims to add call hierarchy support in Haskell Language Server(HLS).</p> <p>Language Server Protocol(LSP) has <a href="https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_prepareCallHierarchy" target="_blank">supported</a> call hierarchy in 3.16, which make us implement it in HLS possible.</p> <p>Inspired by <a href="https://github.com/haskell/haskell-language-server/issues/738" target="_blank">this issue</a>, my proposal involves the following steps this summer to contribute to call hierarchy:</p> <ol> <li><a href="https://github.com/haskell/lsp" target="_blank">LSP</a> spec support.</li> <li><code>prepareCallhierarchy</code> implementation.</li> <li><code>incomingCalls</code> implementation.</li> <li><code>outgoingCalls</code> implementation.</li> <li>Test</li> </ol> <p>I hope I can contribute to HLS to go further this summer.</p>
<p>Figures play a central role in the life cycle of all kinds of research and analysis. That is: The communication of results.</p> <p>What we propose in this project is to extend <code>pandoc</code>’s figure handling capabilities to represent composite figures. This will provide a concise way to construct them compared with the alternative of writing LaTex code; and thus, facilitate source publishing.</p>
This proposal aims to enhance Liquid Haskell’s name resolution mechanism by enabling qualified imports for both (logic) type and predicate aliases. Currently, ambiguities arise when identical aliases are exported from multiple modules, adversely affecting both user experience and internal processing. The proposed solution will modify the internal alias representation and update all relevant use sites to construct fully qualified names, thereby allowing users to disambiguate identical aliases. Additionally, the project will conduct a detailed study of predicate alias use cases to evaluate the potential deprecation of these aliases in favor of the overlapping functionality provided by inline annotations. The primary deliverables include merged pull requests implementing qualified import support for type and predicate aliases, comprehensive documentation, and a blog post detailing design decisions, implementation processes, and the outcomes of the predicate alias study.
Currently LFortran requires that all function parameters to be typed. This makes implementing algorithms supported by many types, tedious. This project will implement generics in LFortran using the same design as C++ 20 concepts for type restrictions. A previously proposed notation will be used. The implementation will be done completely in the ASR level. (Abstract semantic representation). It will introduce a new data type that stores data types (type) and will use it to generate concrete functions from generic functions.
This project aims to enhance the capabilities of neural-fortran, a parallel Fortran framework for deep learning, by implementing additional optimization algorithms. While the framework currently supports training and inference of dense and convolutional neural networks using stochastic and mini-batch gradient descent optimizers, more versatile learning and training from a broader range of problems and datasets require the use of other optimization algorithms such as RMSprop, Adam, and others commonly used in popular deep learning frameworks like Keras. The project will also require work on implementing, documenting, and testing these optimizers, which will broaden the applicability of neural-fortran and allow it to be used for a wider range of deep learning tasks. The successful implementation of these optimization algorithms will provide users with more flexibility and choice when training their models, ultimately improving the performance and capabilities of neural-fortran.
COBOL source files may use different encodings. Commonly, these use some 8-bit character encoding like ISO-8859-15 or an EBCDIC one "transferred as binary from the Mainframe". Newer sources are often written in UTF-8, which can pose challenges for user-defined words and literals stored as single-byte characters. The project aims to support files with different encodings and internally convert between UTF-8, UTF-16, stored as byte arrays.
Trixi.jl is a numerical simulation framework for conservation laws written in Julia. The integration of Trixi.jl with Compiler-Based (LLVM level) automatic differentiation via Enzyme.jl offers the following benefits: facilitates rapid forward mode AD, enables reverse mode AD, supports cross-language AD, and critically, supports mutating operations and caching, on which Trixi.jl relies, to enhance the performance of both simulation runs and AD. The final deliverable will include as many of Trixi's advanced features as possible, such as adaptive mesh refinement, shock capturing, etc., showcasing the benefits of differentiable programming in Julia's ecosystem.
<p>This project aims to add a more flexible asynchronous file system cache server as an engine module. It will cache any IO operations, and provide more flexibility with respect to the caching behaviour. This is particularly useful on non-desktop platforms such as gaming consoles.</p>
JBoss Web Server (JWS) is Red Hat’s enterprise distribution of Apache Tomcat used in production environments where configuration correctness and operational visibility are critical. Many production incidents are caused by configuration errors such as TLS misconfiguration, incorrect connector exposure, proxy misconfiguration, permission issues, and environment drift rather than software defects. This project proposes jws-diag, a read-only Java CLI diagnostic tool designed to help operators and support engineers quickly understand installation state, effective runtime configuration, and potential configuration risks. The tool will provide: • Installation and runtime summary (JWS/Tomcat versions, JVM, OS, container signals) • Effective configuration parsing from server.xml with defaults resolution • Validation rules engine producing INFO/WARN/ERROR findings • Comprehensive test suite with configuration fixtures • Documentation and operational usage guidance • Optional redacted support bundle generation (stretch goal) Key deliverables include: • jws-diag summary command • jws-diag config command • jws-diag validate command with validation rules • Test suite and documentation • Integration into JWS ecosystem tooling The project will initially target: JWS 6 and JWS 7 Tomcat 10.1 and Tomcat 11 The expected outcome is a production-safe diagnostic tool that improves troubleshooting efficiency and configuration reliability for JBoss Web Server deployments.
<p>The aim of this project is to add an interactive music feature to Godot, with similar functionalities to Wwise. Wwise itself cannot be used however, because it’s a proprietary software and functionality cannot be offered. Instead a module with two new classes will be created that offer similar functionalities, AudioStreamTransitioner and AudioStreamPlaylist. They will inherit AudioStream and can be used in AudioStreamPlayers.</p>
<p>A full-screen composer that could be opened from the current composer to provide a larger area for text input or edition, good to send or edit large texts.</p>
Currently, the new, experimental GCC based compiler backend for Rust(`rustc_codegeng_gcc`) is not able to build the Rust compiler. The goal of this proposal is to add the fixes and features necessary for `cg_gcc` to build a fully functional stage 2(and possibly 3) of the Rust compiler. This will require adding support for 128 bit SwitchInt terminators, fixing recursive `#[inline(always)]`, and plugging some soundness holes within the backend. This should help the GCC based codegen become more mature. In the future, this could also open the way towards building and running the Rust compiler on platforms not supported by LLVM. Improving this codegen backend could allow Rust to be used in more places, speeding up the language's adoption.
Currently, the JavaScript engine Boa relies exclusively on a register-based interpreter, which limits its performance. This project proposes implementing the initial version of a Just-in-Time (JIT) compiler for Boa that operates alongside the existing interpreter. Specifically, the JIT compiler will be based on the copy-and-patch technique described by Xu and Kjolstad (2021) and implemented in python/cpython#113464. Unlike traditional JIT approaches that compile code at runtime, copy-and-patch generates executable code by copying precompiled machine code templates and patching them with runtime values such as stack variable offsets. This approach enables measurable performance improvements while avoiding extensive runtime overhead, which is important to Boa’s role as an embeddable engine. The primary goal of this project is to deliver the first JIT compiler for Boa. While only moderate immediate performance improvements are expected, the project aims to provide a solid foundation for future refinement and work toward higher execution speed.
The Solang Solidity Compiler is a new compiler project, which compiles Solidity to wasm or bpf. The compiler does not yet detect if a variable is used before it is assigned, or detecting that a value set is never used. For example: For example: contract test { function f(bool condition) public return (int) { int x; int y = 5; if (condition) { x = 102; } return x; } } This code has two problems: y is never used, and the value of x might be returned without it being given a value. In compiler theory this is done with reaching definitions. Solang already has an implementation of reaching definitions for the constant propagation pass, which will have to be generalized. Unused variables should be removed from the generated code. Secondly, implement a common subexpression elimination pass, which also uses the same reaching definitions implementation, to ensure subexpressions can safely be substituted. Learning Objectives 1) learn how to be a positive collaborator and contributor in an active open source project. 2) Learn how to work within the Hyperledger open source ecosystem and culture. 3) Understand smart contracts and the Solidity language 4) Gain a greater understanding of compiler optimizations and compiler theory Expected Outcome 1) Solang gives errors when undefined variables are used 2) Solang gives warnings when variables are not used, and removes them from the generated code 3) Solang does a common subexpression elimination pass
<p>As Lütkepohl [1] states his preface, "[b]y now [cointegration] related models and methods have become far more important for applied econometric work than, for example, vector autoregressive moving average (VARMA) models." In the context of cointegrated variables especially vector error correction models (VECM) are emphasized in [1].</p> <p>While statsmodels supports VARMA models, it still lacks VECM (<a href="https://groups.google.com/d/msg/pystatsmodels/Dr3_c4BMaiY/JYx0H0gsBgAJ" target="_blank">as suggested by one of the project's main contributors</a>). The GSoC might be a good opportunity to introduce VECM-related functionality into statsmodels. This functionality includes the representation of a VECM, forecasting, estimation, and model diagnostics among other topics.</p> <p>[1] Lütkepohl (2005) New Introduction to Multiple Time Series Analysis</p>
Memory safety is critical to delivering reliable and secure software. This is even more evident with projects like CPython, which is integral to innumerable applications across the world and unfortunately a prime target for attackers. Based on recent guidance by the OpenSSF an effort has been made to look into implementing hardened compiler options for CPython. The phases of this project include establishing benchmarks for existing performance with current compiler options as well as the counts and types of errors. Some work has been done so far to evaluate warnings when compiling with the TL;DR compiler options provided by OpenSSF, but more research should be done to establish candidate flags. Secondly performance analysis should be generated for candidate compiler flags. Warnings should be combed for false positives since this can impact if the work should be undertaken to fix these warnings or not use the compiler flag. Once compiler options have been selected in accordance with desired safety goals, performance analysis, and additional work needed to address warnings then tooling should be implemented to track new violations relative to an existing baseline.
<p>This project adds support for <strong>Custom Performance Monitors</strong> and <strong>Debugger Plugins</strong> to <em>Godot</em>. Just like built-in <em>performance monitors</em>, it tracks user-defined parameters and shows them as <em>line graphs</em> in <em>Godot Editor</em>. <strong>Custom Performance Monitors</strong> cover most use cases. Some special use cases required <em>profiling</em> and <em>visualizing</em> custom data types and <strong>Debugger Plugins</strong> cover those cases. It provides an API to <em>collect</em>, <em>process</em> and <em>transfer</em> profiling data between game and editor.</p>
The Pharo VM is written in Slang, a Smalltalk subset that is transpiled to C by the CCodeGenerator. Currently, the entire VM is generated into a handful of large monolithic C files where code from completely different subsystems the garbage collector, the interpreter, and the JIT compiler are all merged together into a single output stream. This makes the generated code difficult to read, navigate, and maintain, and means that changing a single method triggers recompilation of the entire VM rather than just the relevant module. This project introduces separate compilation to Slang by refactoring CCodeGenerator to route generated C code into multiple files, one per class hierarchy, while correctly tracking and emitting #include dependencies between them. The approach involves extending CCodeGenerator to maintain per-hierarchy output streams, implementing a dependency graph builder to determine which hierarchies reference which others, generating corresponding header files with the necessary forward declarations and prototypes, and updating the CMake build system to automatically discover the new files. The deliverables are: a working dependency graph builder for TMethod objects, a refactored CCodeGenerator supporting multiple output streams, successful extraction of the SpurMemoryManager garbage collector hierarchy into its own standalone C file with correct includes as a proof of concept, header file generation for all separated modules, extension of separate compilation to the Cogit JIT compiler and remaining hierarchies, and an updated CMake build configuration. All existing VM tests will pass throughout, ensuring no regressions in the generated code.
The project aims to centralize the P4 compiler (p4c) documentation by developing a new, well-structured documentation website using Doxygen for automated content generation. It will utilize GitHub Actions to automate build and update processes and introduce a PR preview system, enabling contributors and maintainers to review documentation changes before merging. These efforts will establish a clear, accessible, and organized website, making it easier for all members of the P4 community to navigate and maintain.
<p>In this project, we aim to detect whether compiling a file in parallel can improve the compilation performance. If so, then we proceed the compilation in this way.</p>
<p>This project is aimed to provide a fixed point compiler backend for the <code>fixbv</code> type defined in <a href="http://dev.myhdl.org/meps/mep-111.html" target="_blank">MEP-111</a> of MyHDL project.</p> <p>When the project finishes, MyHDL should have a complete implementation of <code>fixbv</code> and its compiler backend with complete documentation, include tutorials and reference.</p>