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 Hurd is the kernel of the GNU system. It consists on the GNU Mach microkernel and several user-space servers that offer most of the functions that usually a kernel offers, one of these functions is a TCP/IP stack. Currently, in the Hurd this stack if offered by the pfinet server, a port of the Linux 2.2 TCP/IP stack. This stack should be replaced since it is obsolete and lacks important features like PPP support. In this project, we will port LwIP TCP/IP stack to the Hurd to replace pfinet.</p>
CPAchecker now supports reachability analysis, which can search for a path from the initial program location to the error location. This project is a Proof of Concept, to implement the Backward Reachability Analysis, i.e. search for a path from the error location to the initial location. The main goal of this project is to implement a control-flow automata (CFA) transformer in CPAchecker that reverses program executions by following the transitions backward, such that for any program path in the original CFA, there is a corresponding equisatisfiable path in reverse CFA. After the transformation, the existing analysis can be applied to verify the reverse CFA, thus enabling the Backward Reachability Analysis.
This project aims to modernize Webpack by implementing comprehensive support for ECMAScript Modules (ESM) output. Webpack currently lacks robust ESM output capabilities, creating challenges for developers working with modern JavaScript. The implementation will focus on four key areas: parser and module analysis enhancements to detect strict mode compatibility issues and identify statically exportable modules; code generation improvements to properly transform CommonJS to ESM exports; runtime optimization to eliminate unnecessary boilerplate; and platform-specific feature support for CSS modules, URL handling, and ESM workers.
<p>Although the DBPedia Extraction Framework was adapted to support RML mappings thanks to <a href="https://summerofcode.withgoogle.com/archive/2016/projects/5147656280080384/" target="_blank">a project of last year GSoC</a>, the user interface to create mappings is still done by a MediaWiki installation, not supporting RML mappings and needing expertise on Semantic Web. The goal of the project is to create a front-end application that provides a user-friendly interface so the DBPedia community can easily view, create and administrate DBPedia mapping rules using RML. Moreover, it should also facilitate data transformations and overall DBPedia dataset generation.</p>
DeepChem supports transformer-based foundation models for chemistry (ChemBERTa, MolFormer) but has no equivalent for genomic data. This project fills that gap by integrating DNABERT-2 into DeepChem, following the same design pattern used by ChemBERTa and MolFormer. The implementation consists of two components: (1) a DNABert model class that wraps HuggingFace's DNABERT-2 inside DeepChem's HuggingFaceModel/TorchModel hierarchy, supporting masked language modeling pretraining and fine-tuning for classification, regression, and multitask regression; and (2) a DNABertTokenizer that serves as both a HuggingFace tokenizer and a DeepChem featurizer, making it compatible with DeepChem's data loading pipeline. Deliverables include the fully integrated model and tokenizer classes, tests across all task modes, and benchmarks on a suitable genomic dataset.
GPU computing provides substantial performance gains over CPU-based methods for computationally demanding tasks. Trixi.jl, a Julia numerical simulation framework for hyperbolic conservation laws, currently lacks native GPU support. This project aims to accelerate PDE discretization in Trixi.jl using GPUs via CUDA. Key subtasks include developing a simple 1D CPU code, extending it to 2D and 3D, porting it to GPUs, prototyping GPU implementations of existing Trixi.jl kernels, optimizing data transfer, and expanding GPU support for more complex methods and GPU types. The final deliverable will offer high-performance PDE solvers on GPUs, showcasing the benefits of GPU acceleration in Trixi.jl.
The integration of automatic differentiation (autodiff) into the Rust compiler via Enzyme faces challenges due to ABI adjustments that alter function signatures. These transformations, while beneficial for performance, interfere with autodiff functionality, leading to incorrect differentiation. This project aims to prevent unwanted ABI adjustments for functions marked with #[rustc_autodiff], ensuring autodiff functions maintain their intended behavior without affecting other optimizations. The approach involves modifying Rust’s function ABI handling to recognize and preserve differentiation-related information. Key steps include identifying problematic transformations, encoding autodiff metadata in FnAbi, and preventing ABI changes that break autodiff. By addressing these challenges, the project will improve autodiff support in Rust, making it more reliable and consistent while preserving compiler efficiency.
Graphite currently offers only a limited set of shape tools with basic gizmo support, limiting the scope of creative and precise editing. This project aims to enhance the Polygon Tool by introducing a variety of predefined shape nodes—such as Trapezoid, Star, Donut, Pie, Crescent, and more—each equipped with custom, interactive gizmos. To manage these features, a centralized Gizmo Manager will be developed to handle both general transform cages and shape-specific gizmo points. These gizmos will integrate with the Select Tool using a state-driven interaction model to enable intuitive, fine-grained shape manipulation. Each shape will expose unique transformation controls (e.g., adjusting edge curvature, radii, angles, and segment lengths), allowing users to craft complex designs efficiently.
This project will build a portable Kafka Streams runner for Apache Beam so that Beam pipelines can run on Kafka Streams using the Beam Fn API. The runner will translate portable Beam pipeline protos into Kafka Streams topologies and support a working skeleton for core transforms: Read, stateless ParDo, GroupByKey, Combine, non-merging windowing, and Flatten. The implementation will focus on correct watermark propagation, commit-based bundle boundaries, exactly-once semantics, and integration with the existing Beam portability stack. Deliverables include a new runners/kafka-streams module, runner entry points, a pipeline translator with transform-specific translators, watermark and bundle management, tests using TopologyTestDriver and real Kafka-based integration coverage, and documentation for the Beam community.
This project aims to integrate the official GHC/WebAssembly backend into xeus-haskell, a Jupyter kernel for Haskell. Currently, the kernel relies on MicroHs, which, while lightweight, lacks support for the vast majority of the Hackage ecosystem. I will implement a dual-backend architecture by introducing a new C++ bridge and a reactor-model Wasm REPL module based on the GHC API. Key deliverables include: GhcRepl: A GHC-based WebAssembly REPL module maintaining persistent session state. C++ Bridge: A new interface (ghc_repl.cpp) to communicate with the GHC/Wasm runtime via the Wasm C API. Backend Abstraction: A unified virtual interface to allow seamless switching between MicroHs and GHC/Wasm. WASI Integration: A configured browser shim to handle I/O and package database access within JupyterLite
<p>360° video is getting popular during the past years and it is predicted to evolve [1]. Compared to virtual and augmented reality, 360° video is much more accessible for viewers. The cameras are getting cheaper, and many video sharing services have an option for 360° video support (YouTube, Vimeo, Facebook) as well as applications (e.g. VLC).</p> <p>360 video requires special transformations to be viewed: the most popular way to store the data at ERP and CMP projections.</p> <p>The goal of the project is to implement and optimize ERP and CMP conversion algorithms using GLES. The algorithm will perform 360° video transformations between ERP and CMP. [1] <a href="https://images.app.goo.gl/iVyk3qkdxmR7CNGA8" target="_blank">https://images.app.goo.gl/iVyk3qkdxmR7CNGA8</a></p>
PreliZ is a Python package aimed at helping practitioners choose prior distributions by offering a set of tools for various facets of prior elicitation. The main objective of this project is to expand these features and make them more robust, transforming PreliZ into a tool that easily integrates with other libraries such as PyMC, Bambi, and PyStan, while remaining agnostic to Probability Programming Languages (PPLs). The key outcomes of this project include generalizing Bambi's parsers, integrating PyMC for interoperability, establishing a common infrastructure for future PPLs, extending the `predictive_explorer` function to handle multiple inputs and outputs from various PPLs for comprehensive prior predictive distribution plotting, enhancing the `ppa` function to support models from PreliZ, PyMC, or Bambi for interactive prior updates, and improving the handling of PyMC models within PreliZ's `ppe` function while extending support to PreliZ and Bambi models.
This project focuses on transforming Mogan STEM into a web-based, multi-user collaborative platform. Currently, the lack of a functional WebAssembly (WASM) version and real-time synchronization limits its use in modern collaborative research. To solve this, I will compile Mogan STEM using Emscripten, implementing a custom virtual file system to ensure stability. Furthermore, I will develop a real-time collaboration core based on Operational Transformation (OT) and WebSockets. This architecture allows multiple users to edit complex scientific documents simultaneously with "local-first" responsiveness and guaranteed global consistency. Deliverables include: 1. A stable browser-based version of Mogan STEM. 2. An OT-based synchronization server. 3. A complete end-to-end prototype supporting real-time multi-user collaborative editing.
Cantor is a core tool in the KDE ecosystem that focuses on scientific computing and interactive analysis. It supports mathematical modeling and data visualization through engines such as Python, Julia, and Maxima. In order to improve its text editing experience and maintainability, this project plans to deeply integrate the KTextEditor framework to transform Cantor into a more "developer-friendly" scientific research platform. By using QGraphicsProxyWidget to seamlessly replace existing custom cells, professional functions such as Vi editing mode, intelligent code completion, dynamic syntax highlighting (supporting user-defined symbol injection) are implemented, while simplifying the code structure and reducing redundant component code. This improvement not only aligns Cantor's editing experience with KDE professional tools such as Kate and KDevelop, but also lays the foundation for future integrated debuggers, version control and other advanced functions by sharing the KTextEditor plug-in ecosystem.
This project focuses on extending the R interface of the torchvision library by implementing support for core computer vision datasets and model architectures. The scope includes adding native loaders for widely used datasets such as COCO and VOC, along with support for key models including Faster R-CNN, Mask R-CNN, FCN, Keypoint R-CNN, and quantized ResNet variants. The proposed work enhances the torch ecosystem in R by enabling advanced computer vision workflows with consistent APIs, GPU compatibility, and clean documentation. The implementation will follow package development best practices with robust testing, reusable components, and user-friendly examples. The resulting contributions aim to reduce the gap between R and Python in deep learning tools, enabling R users to build scalable, efficient, and modern vision pipelines.
<p><strong>CiviREBUX</strong> is an native CiviCRM extension for drafting custom Contribution and Membership reports via a drag-n-drop interface. <strong>CiviREBUX</strong> combines powerful visualization and transformation techniques which gives the users the full capabilities of modern browsers and the freedom to design the right elements for their reports. <strong>CiviREBUX</strong> also supports saving and loading of report templates for later use. It works well with all the 3 CiviCRM-supported CMS - Wordpress, Drupal and Joomla, hence native.</p> <p><strong>CiviREBUX</strong> integrates seamlessly within the CiviCRM Dashboard and goes live seconds after installing the extension. <strong>CiviREBUX</strong> is a mix of the most popular desktop-based spreadsheet software and fast browser applications, essentially, <em>a spreadsheet software running on your browser</em>.</p>
This project would integrate the current state-of-the-art 3D reconstruction method in computer graphics namely "Gaussian splatting" with existing rendering systems in CB-Geo MPM to enable simulations from videos using the Material Point Method. It will enable video data from real-world phenomena such as landslides to be transformed directly into simulations. This project will make use of Gaussian splatting to extract 3D graphics primitives from videos. These primitives will then undergo simulation through the Material Point Method. Hence the project will involve adding support for Gaussian Splatting as well as support for MPM simulations on obtained splats/particles/primitives. Another very interesting research aspect explored in this project was deriving material properties such as young modulus, friction angle etc. by leveraging JAX's differentiability. This leads to deriving material properties from just videos!
<p>LLVM Project is a collection of modular and reusable compiler and toolchain technologies. It supports various high-level languages and hardware architectures. LLVM IR is an SSA-based intermediate representation whose design helps in the easy and efficient implementation of various compiler optimizations and transformations. Alive2 is a tool that checks whether the transformation of an instruction set into another instruction set is semantically correct or not. It is a verification framework for LLVM IR, which checks whether the source and target IR are equivalent or disproves by providing a counterexample. Alive2 can reason about a wide variety of intraprocedural optimization problems, including control flow, memory, vectors, and floating-point. Alive2 has detected some fundamental issues in the LLVM-IR, which lead to mis-compilation and unsound optimizations. In this project, I propose to solve some of these issues in the LLVM IR by making some changes to the LLVM compiler infrastructure code.</p>
<p>The WARP-V is an open-source and highly configurable, adaptable, and flexible Core generator. It supports various ISA like MIPS, Open-Source RISC-V, and can even be configured with custom ISA. It is designed using emerging “Transaction-Level” modeling that takes advantage of advanced digital design features, timing-abstract nature of language features provided by TL-Verilog. My Project Proposal to harness its advantages and develop support for the multicore NoC design creating a custom kernel interface and deploying it on the cloud via the already existing 1st CLaaS framework. This project will not only lead to a highly configurable many-core hardware accelerator but it will also serve to motivate the industry toward FPGA-accelerated web applications and FPGA-accelerated cloud computing and also to demonstrate the flexibility of TL-Verilog and WARP-V to motivate the industry toward better design methodology.</p>
In high-energy physics (HEP), automating the symbolic computation of squared amplitudes is essential for predicting cross-sections and validating theoretical models against experimental data. Current transformer-based approaches excel in sequence modeling but falter in capturing the relational structures and physical consistency required for HEP expressions, such as those involving gamma matrices and Mandelstam variables. To tackle this, I propose the Physics-Informed Performer (PIP), a novel framework that integrates the Performer transformer’s efficient kernel-based attention with a physics-informed tokenization scheme and a SymPy-based validation layer. This approach leverages Performer’s ability to handle long sequences, introduces tokens like <SQUARE> and <S> to embed HEP-specific operations and kinematics, and ensures symbolic accuracy through empirical post-processing. By focusing on data representation, PIP offers a computationally efficient alternative to traditional symbolic methods, tailored to the Task 1.2 dataset of amplitude-to-squared-amplitude mappings.
At the moment, Unikraft can leverage a single processor only. While there can be multiple threads (i.e., multiprogramming), no two activities actually run at the same time (i.e., multiprocessing). Unikraft introduces support for symmetric multiprocessing (SMP), thereby allowing it to execute code on all processors and cores of a system concurrently. This creates new challenges for synchronizing access to shared resources. On a single-processor machine synchronization primitives like mutexes and semaphores can consider interrupts as the only source of parallel execution. It is thus sufficient to protect a critical section of code by temporarily disabling interrupts. With SMP, however, this is no longer sufficient as other processors may access shared resources at any time. The project will involve studying locking mechanisms used in modern kernels like Linux, FreeBSD, etc, improving the existing locking mechanisms in unikraft, and implementing new mechanisms such as read-write. The important part of the project will be identifying the critical sections present in the kernel and protecting these critical sections.
Maglev is OneBusAway's next-generation, high-performance Go REST API server designed to replace the legacy Java architecture. To achieve full production readiness for real-world transit agency deployments, this project focuses on four core deliverables. First, it ensures strict 1:1 API parity through automated, field-by-field output validation against the legacy server integrated directly into CI. Second, it executes a complete Go rewrite of the GTFS merge and transformer modules, creating native CLIs that enable runtime multi-feed loading directly into Maglev. Third, the project integrates the GTFS-Flex specification to support demand-responsive paratransit services, and finally, it expands the existing GTFS-RT pipeline to handle real-time structural trip modifications. Together, these enhancements will transform Maglev from a fixed-route Western transit tool into a globally deployable platform capable of serving diverse transit ecosystems across South Asia, Africa, and Latin America.
<p>Synthesis is at the heart of organic chemistry. It is the process of constructing a molecule through a series of reactions. Efficient molecular synthesis is significant, especially in areas like medicinal chemistry. However, it can be challenging to plan a synthesis for a complex molecule.</p> <p>Retrosynthesis is an iterative process of breaking down a target molecule into a series of simpler molecules which are readily available. It provides a systematic way to plan a chemical synthesis. But, as the space of possible chemical reactions is vast, it is hard for chemists to make the right disconnections while optimizing for multiple factors such as the cost of precursors and efficiency of the reaction.</p> <p>At its heart, the challenge of making a single retrosynthesis prediction can be recast as a Machine Translation task. Consequently, Natural Language Processing techniques can be leveraged to tackle this using Deep Learning.</p> <p>This project is focused on extending the DeepChem Library to support Retrosynthesis models, specifically to make single step predictions. This will be achieved by implementing a Molecular Transformer model and enhancing support for Reaction datasets.</p>
<p>Spoon is an open-source library to analyze, rewrite, transform, transpile Java source code. It parses source files to build a well-designed AST with powerful analysis and transformation API. It fully supports modern Java versions up to Java 11.</p> <p>Spoon has a lot of methods whose testing can be improved. For many methods, deciding an arbitrary return value doesn’t change the test results.</p> <p>There is a full list of pseudo and partially tested methods which need improvements in testing. This list contains around 240 methods whose tests need improvement. Apart from this, there might be some methods that aren’t on that list and need addition/improvements in testing.</p> <p>Although around 240 methods need improvements in tests, I believe it may not be feasible to improve all 240 in a limited time.<br> I am planning to add/improve tests for 30-40 or a pre-decided number of methods under this project. I may improve the rest after the program ends.</p>