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.
This project aims to automate metadata harmonization for cBioPortal, a widely used platform for cancer genomics research. Currently, metadata from different studies often uses inconsistent terms, limiting cross-study analysis and making it harder to apply AI/ML models effectively, while manual harmonization is time-consuming and not scalable. To address this, I propose building an automated metadata harmonization tool using fine-tuned biomedical sentence transformer models to semantically match and standardize metadata terms. The pipeline will include data preprocessing, semantic matching, low-confidence flagging, and expert validation, with interfaces to support expert review. The key deliverables are a fully functional metadata harmonization pipeline, semantic similarity models fine-tuned on curated biomedical data, a persistent vector database for scalable and reproducible retrieval, and documentation with testing coverage. This tool will reduce manual curation time by over 70%, improve metadata consistency, and enhance the platform’s readiness for AI-driven research.
Open Food Facts Explorer is a next-generation frontend for exploring and contributing to the Open Food Facts ecosystem, built with modern technologies like SvelteKit. It aims to achieve full feature parity with the main platform by keeping it modern, scalable and contributor-friendly. This project aims to enhance Explorer by adding multi-platform support (Open Food Facts, Open Beauty Facts, Open Pet Food Facts, and Open Products Facts), improving product addition and editing workflows, integrating Open Prices and moderator only features and tools like Nutri-Patrol directly into the app. It will also introduce enhanced search capabilities and Robotoff-powered features to assist contributors. From a technical perspective, the focus will be on decoupling the frontend from the backend by strengthening the SDK usage, and leveraging reusable web components where appropriate while maintaining SvelteKit’s SSR benefits. “Transform openfoodfacts-explorer from a food-only prototype into a complete, multi-platform contribution tool that achieves feature parity with the main OFF website"
<p>The project aims to bridge the AIMALL and Molden programs with cclib by adding support for writing wfx/wfn files and Molden format files.</p> <p>Molden program supports reading input from GAMESS, Gaussian and MOPAC and some user written scripts add support for some other programs. cclib being the largest parsing library for QM program outputs could provide a one stop solution for making Molden files.</p> <p>Bader's Atom in Molecule is a popular method to characterize individual atomic contributions to the electron density to much more intuitive atoms and bonds. AIMALL is the go-to program for doing AIM analysis. Having a wfx/wfn writer within cclib would bridge the two programs.</p> <p>As stretch goals, I propose implementing either updating write support for .cube files which can be used with Henkelman group’s fast implementation for Bader charge integration or start building a parser for Molcas. The former is in-line with cclib's attempt to include modules for advanced analysis of quantum chemistry data, while support for the latter is a requested in cclib's github repository.</p>
<p>DIPY is an open source software mainly focusing on diffusion Magnetic Resonance Imaging (dMRI) analysis. For nonrigid image registration, it implements a Symmetric Normalization framework. The major goal of this framework is to calculate an affine or deffeomorphic transformation to register two 2D images or 3D volumes. As a well-known problem, registration is a non-convex optimization problem. It is very important to initialize as close to the solution as possible. So in order to avoid getting stuck at local optima, it uses a multi-resolution strategy by building a Gaussian Pyramid. That is to say we can register our images in as many stages as we want, providing previous results as initialization for the next. As this way, we need to do a lot of iterations, thus it slow down the optimization process. To speed up the calculation, one solution is to convert to a parallel computing algorithm. The OpenMP API supports multi-platform shared-memory parallel programming in C/C++ and Fortran. So in this project, I will implement a multi-thread algorithm using OpenMP to improve the performance of nonrigid image registration in DIPY.</p>
Monoclonal antibodies (mAbs) are a potent therapeutic because of their ability to precisely target molecular surfaces at a sub-protein level resolution. They are used in cancer checkpoint blockades, treatments for viral infection, and useful in situations of snakebites as anti-venom. Current methods of antibody discovery involve inoculating various chimeric animal constructs with specific antigens and isolating and purifying antigen-specific molecules. As such there has been a significant interest in designing antibodies in-silico. A growing number of large language models have been employed to capture the sequence distributions of these proteins, with varying degrees of success. However, the vast majority of language models are encoder-only transformers whose target-conditioned sequence generation capabilities are limited, and their code is prototypical rather than production ready. This project aims to integrate and finetune a target-conditioned LLM for eptiope-specific antibody design. Extending DeepChem's codebase to include support for this class of therapeutics would not only help democratize this technology for resource constrained operations, but also bring these groups onto a platform with a lively user base and healthy collaborative environment.
This project focused on transforming FOSSASIA’s static web infrastructure into a dynamic, scalable, and contributor-friendly WordPress ecosystem. The goal was to migrate Codeheat.org from GitHub Pages to WordPress, introduce reusable templates for generating yearly contest sites, and improve FOSSASIA’s overall web workflows. Alongside the website migration, I integrated widely used open-source plugins—such as Contact Form 7 and Noptin—to enhance community interaction, mailing list management, and content organization. A key part of the project involved extending and improving the wpfa-mailconnect plugin by adding SMTP configuration, email logging, and a more reliable internal architecture. These changes make communication systems easier to maintain and expand across multiple FOSSASIA websites. Throughout the project, the focus remained on creating maintainable solutions with minimal custom code, ensuring long-term scalability and ease of adoption for contributors. The result is a modernized, more flexible web foundation that supports improved performance, better content management, and future integration with additional FOSSASIA tools.
This project focused on upgrading the existing pgwatch Grafana dashboards to ensure full compatibility with the latest Grafana version 12. While some dashboards had already been partially migrated, many still relied on outdated components and required manual refinement to ensure optimal performance. Grafana v11 had introduced significant changes, including the removal of AngularJS support and updates to panel JSON structures and transformation capabilities. With the release of Grafana v12, further enhancements and updates were made, making it crucial to migrate all dashboards to take full advantage of the new visualization features and capabilities. The primary objective of the project was to update the dashboards, ensuring they were fully functional with Grafana v12, while also improving usability and maintaining high performance. This involved not only updating the visualization elements to align with the new version but also addressing any deprecated components and optimizing the dashboards for a smoother user experience.In addition to the technical upgrades, the project included comprehensive documentation to guide future maintenance and ensure ease of future updates. This approach ensured the longevity and continued efficiency of the dashboards in a rapidly evolving Grafana ecosystem.
<p>GeneTech allow users to develop genetic logic circuits only by specifying a Boolean function. The tool first performs Boolean optimisation, followed by synthesis and technology mapping. Currently, a user can define the desired behavior in the standard Boolean notation. I would like to add the support for designing a circuit via drag and drop method on a design canvas. This functionality would allow users, specially electrical/electronic engineers, to design a genetic circuit by constructing the circuit schematic on a design canvas using drag-drop-wire approach. GeneTech will then transform the circuit schematic into the corresponding genetic circuit and represent it in the standard SBOL notation. The results produced by the current version of GeneTech do not include the DNA basepair encoding of circuit components. I would like to update the tool to be able to embed the DNA sequence of generated circuits in the SBOL file.</p> <p>Most of the code-base of GeneTech is currently a pre-compiled version of the Java code which adds additional overhead and dependencies. We would also like to convert the Java code to Python and reduce dependencies along the way</p>
This project focuses on systematically expanding regression test coverage for the ESP codebase by targeting high-risk, untested logic paths rather than merely increasing overall coverage percentage. Through detailed codebase exploration, critical gaps have been identified in components such as lottery assignment logic, class registration flows, and mailman integrations. These areas involve complex logic, invariants, and edge cases that currently lack sufficient test coverage and pose a high risk of silent regressions. The project introduces invariant-based testing for the lottery system to ensure correctness properties such as no conflicts, no overcapacity, and valid grade constraints across arbitrary inputs. Additionally, integration tests will be implemented for mailman functionality using mocking to validate subprocess interactions without external dependencies. A reusable testing infrastructure will be developed to support scalable regression testing, along with targeted performance checks to detect potential degradations in critical views. The outcome will be a robust regression testing framework that transforms fragile, untested paths into enforceable guarantees, significantly improving system reliability and maintainability.
The goal of this project is to reintroduce a tree view functionality into Chrome's bookmarks side panel, addressing user feedback and enhancing usability. The current flat list view lacks the ability to view all bookmarks at once, leading to user dissatisfaction. To solve this, we will transform the compact view into a tree view while retaining all new features introduced in the recent UI overhaul. This will involve retaining drag-and-drop functionality for bookmark organization within the tree view, ensuring compatibility with screen readers, and conducting comprehensive testing for usability and accessibility. Key Deliverables: 1. Implement tree view functionality in the bookmarks side panel, allowing users to view all bookmarks at once. 2. Update existing drag and drop functionality for organizing bookmarks within the tree view. 3. Ensure accessibility standards are met, focusing on tab traversal and screen reader support. 4. Conduct thorough testing to ensure the usability, accessibility, and functionality of the tree view. 5. Prepare comprehensive documentation detailing the implementation, usage, and features of the new tree view in Chrome's bookmarks side panel.
Greece’s public business records, available through the GEMI portal, contain valuable information such as company names, founding dates, and key individuals, but much of it is locked away in difficult-to-search PDFs. To make this data more accessible, we’re building an open-source tool that transforms these documents into a searchable, user-friendly database—legally and ethically. Instead of scraping, we will systematically fetch records from Greece’s official Open Data Portal, extract metadata and text using OCR and NLP tools , and organize everything in OpenSearch, which efficiently handles Greek text. A simple REST API will allow users to query companies, dates, and individuals while ensuring scalability, smart search, pagination, and overload protection. The project will provide an automated pipeline for downloading, processing, and indexing documents, along with clear documentation, Docker support, and easy cloud deployment. By unlocking these records, we’re not just solving a technical problem—we’re making public data truly public, empowering watchdogs, entrepreneurs, and citizens to better understand Greece’s business landscape.
<p>Machine Learning algorithms for data analysis makes new areas such as Big Data analysis. Emerging data analysis with the streaming data is one of the most paramount areas that will be pioneered the businesses in the future. WSO2 ML (Machine Learner) is one of the main platforms which building some intelligent and predictive data analysis based on the machine learning algorithms to support modern data transactions. Even though they have ML which is build upon the well known Apache Spark MLLib, WSO2 ML still could not support streaming data. Even though the Spark MLLib has streaming support for k mean clustering and generalized linear regression (GLR) , it developed with a Scala API. Purpose of this project is to develop a Java API to support streaming k mean clustering and GLR with the mini batch sampling techniques to support streaming data without using Spark streaming. Therefore design include a way to acquire streaming data and break those data streams into mini batches which can be used this batches to retrain the models periodically with some optimization techniques such as Stochastic gradient descent algorithms.</p>
Healthcare data is critical for decision-making, but the FHIR (Fast Healthcare Interoperability Resources) format, while powerful, can be challenging to navigate for many users. Our project addresses this accessibility gap by creating an intuitive tabular viewer that transforms complex nested FHIR resources into easy-to-understand tables. We're developing a Python-based solution that will automatically extract and organize FHIR data into user-friendly tables, making it immediately more accessible to researchers, clinicians, and community organizations. By simplifying how people interact with health data, we remove technical barriers that often prevent valuable insights from reaching those who need them most. Our deliverables include: A Python library that converts FHIR resources to tabular format An interactive web interface for exploring and filtering the data Documentation and examples to support adoption by various user groups Integration with existing FHIR servers for seamless data access This tool will democratize access to health information by making complex data structures approachable for everyone from data scientists to community health workers. When healthcare data becomes truly accessible, it empowers better decisions and ultimately improves health outcomes in our communities.
This project is about extending the gamboostLSS package by flexible copula regression via gradient boosting. Currently the framework only supports univariate responses, but there is a need to model two correlated outcomes with arbitrary marginal distributions (continuous, discrete, binary or mixed) and their dependence structure modelled through the copula. At the core of this project stands the CopulaFamilies() constructor that combines any two existing gamboostLSS family objects with a copula of the user's choice (Gaussian, Clayton, Gumbel or Frank). The constructor automatically detects the marginal types of the input and computes the appropriate joint log-likelihood, as well as the gradients via chain rule. This computation and its results integrate seamlessly into the already existing interface of gamboostLSS(), extending the cvrisk() for multi-dimensional tuning of the stopping hyperparameter and adding a transformation of the dependence parameter to the Kendall's Tau measure for summary() and plot() to establish interpretable dependence estimates. The deliverables for this project include the CopulaFamilies() constructor with automatic full marginal type detection, gradient stabilization for a method of choice (MAD, L2), model selection on the basis of predictive risk minimization, a predict() method for the evaluation of joint cumulative distribution functions and a vignette to demonstrate the full workflow on a real dataset.
I propose to work on the creation of a DMA-BUF backend for waycrate’s libwayshot screen capture library. Presently libwayshot’s method of screen-capture requires copying from graphics memory to system memory via CPU using the shared memory methods of the wlr-screencopy protocol. This method has too much overhead for uses like high resolution streaming: any further transforms and processing of the image will either be performed on CPU (inefficient) or require another copy back onto graphics memory. There is a better way to do this. The DMA-BUF (short for Direct Memory Access Buffer) is a Linux kernel framework that allows for efficiently sharing buffers of memory between multiple graphics devices or subsystems. Using the DMA-BUF export mechanisms in wlroots we can completely avoid downloads and uploads between graphics memory and the CPU, thus allowing for increased efficiency and performance. This will be especially noticeable on higher resolution screen-captures where individual frame buffers become too large to be efficiently dealt with on a CPU compared to how they can be handled on the GPU. The Deliverables for this project are: Complete implementation of a high-performance DMA-BUF based screen capture backend in libwayshot, Documentation for using it.
This project proposes integrating NVIDIA's Thrust parallel algorithms library with HPX to enable GPU acceleration while maintaining consistency with HPX's existing parallel algorithm interfaces. The solution involves creating a specialized Thrust executor that extends HPX's CUDA executor capabilities, implementing automatic memory management for data transfers between host and device, and developing a dispatching mechanism that selects the appropriate backend (CPU or GPU) based on execution policies. Key technical components include a version-aware API layer to handle Thrust compatibility, exception handling that bridges Thrust/CUDA errors with HPX's error system, and template-based algorithm overloads that transparently route calls to Thrust implementations when GPU execution is requested. The implementation will proceed through four phases: establishing core infrastructure (executor, memory management), integrating fundamental algorithms (transform, reduce, sort), adding HPX execution policy support, and concluding with comprehensive testing and optimization. The resulting system will allow developers to write single code paths that automatically leverage GPU acceleration through Thrust when available, all while maintaining HPX's asynchronous execution model through future-based interfaces.
This project focused in converting the concept of Magic ePaper App into a feature-packed, cross-platform app for personalized ePaper display powered by NFC. Central to it is a robust image editor, developed on the basis of the pro_image_editor package, offering users simple yet effective tools for painting, text styling, and embedding emojis, as well as tuned image adjustment controls. Key achievements encompass the creation of a sophisticated image processing pipeline, complete with advanced dithering filters such as Atkinson and Floyd-Steinberg. Additionally, a dynamic color quantization system was designed, adeptly adapting to the specific palette of the chosen hardware. Importantly, support for a new range of Waveshare displays was seamlessly integrated by harnessing their native SDK; this was accomplished through a Flutter Method Channel coded in Kotlin. In addition to the fundamental editor and image pipeline, new functionality was added directly into the edit experience, such as a flexible Barcode Generator, Customizable Design Templates, and an XBM Export capability. I also established the groundwork for internationalization (i18n) and added out the CI pipelines with GitHub Actions for auto-building and running Integration tests. The project is now an agile and accessible tool that enables users to quickly create dynamic, green content for ePaper badges.
The objective of this project is to create a comprehensive Python tutorial on G-API, a graph execution framework for OpenCV. The tutorial will cover fundamental and advanced concepts related to G-API, such as defining and executing graphs, developing custom operations and kernels, and utilizing numpy inter-op. The anticipated result is a series of new tutorial chapters integrated into the OpenCV documentation, ideally structured in a similar format to the existing documentation. This tutorial will enable users to leverage the power of G-API more effectively, along with optimized image processing tasks and improved performance. The G-API framework, developed by OpenCVQ, is designed to streamline image processing algorithm flow. Its primary objective is to create graphs that can support multiple backends, resulting in lightweight and fast image processing tasks. For instance, when running the algorithm flow on a GPU, optimized video memory access can reduce system overhead and enhance computational speed. To use G-API effectively, it is essential to (1) understand the framework's overall architecture and features, (2) compare its processing algorithms to those of other common frameworks, identify the unique benefits of each G-API function, and (3) combine these advantages and new features to enhance existing tutorials.
Polygons are defined by one outer ring and possibly multiple inner rings representing holes, where each ring is usually represented as a sequence of points. This allows for several undesirable configurations, such as self-intersecting rings, badly nested rings (inner outside outer), and inner rings that split the interior of the polygon into multiple disjoint parts. Such undesirable configurations are considered as invalid polygons in many applications, such as in Geographic Information Systems through ISO 19107. The aim of this project is to incorporate the polygon repair method originally described in https://doi.org/10.1016/j.cageo.2014.01.009 (but later improved) as a CGAL package. This method consists of three steps: (1) a constrained triangulation of the polygon, (2) labelling of its faces as interior/exterior, (3) extraction of the resulting polygon(s) from the sets of labelled triangular faces. The method is already implemented using CGAL and freely available as prepair: https://github.com/tudelft3d/prepair. Integrating it with CGAL as a new package would likely involve switching the code's GDAL dependency with new functions for native CGAL types, adding some functionality in the CGAL 2D/3D Triangulations package (proper deletion of constraints), and the writing of CGAL-style templated code (with support for different kernels and so on).
<p>Many users of Open Ephys are using optogenetic tools to manipulate activity in genetically defined neural circuits, but there is currently no way to control these tools from the Open Ephys GUI. <a href="http://www.open-ephys.org/cyclops/" target="_blank">Cyclops</a> is a high-precision LED driver designed for precise optogenetic stimulation. Setting up a controlled closed-loop experiments, <em>where neurons can be stimulated based on real-time acquired neural data</em>, would be greatly simplified if a plugin to communicate with Cyclops is built into the GUI.</p> <p>A typical scenario would be to upload or stream waveforms to Cyclops and trigger their deployment <em>(or transformations)</em> based on events detected in GUI. An <strong>open communication protocol</strong> needs to be defined for this and also <strong>special programable processors</strong> that can generate feedback signals and control Cyclops <em>(via the protocol)</em>.<br> After configuring the processors in the pipeline, the GUI would program Cyclops and the experiment can be launched.</p> <p>In addition to this, a more powerful and upgraded Cyclops that uses a <a href="http://www.pjrc.com/teensy/" target="_blank">Teensy</a> board will be released. Cyclops and Open Ephys would still support the Arduino version though.</p>
Project Description While the Linux network stack evolved throughout the past years with support for new protocols and features, it has become more complex, which introduces overhead and currently hampers its throughput potential. The idea in this proposal is to intercept an incoming data package as soon as possible inside or even before the Linux network stack through the eBPF XDP or TC hook. To implement this, a combination of an eBPF kernel space and a user space program is needed. While the user space will parse OpenWrt Firewall rules and pass them through a BPF map to the eBPF program, the eBPF program will parse incoming packages, apply the rules for matching packages, and redirect or drop the package. Benefits to community networks The OpenWrt community could possibly benefit from higher throughput for traffic on their (CPU-limited) embedded devices. Especially since current WiFi chips are going to provide above 1GBit/s wireless throughput, the need for an efficient data plan for rule-based packet processing (forwarding, mangling, and dropping) is needed. Within this project, we address this with the offloading capabilities from eBPF within the Linux network stack. Milestones * Creation of an eBPF package forwarder * Creation of a user space program for loading and communicating with the eBPF program * Extend the user space program with a Firewall rule parser * Apply the parsed rules on incoming packages in the eBPF program * Evaluate the performance of the implementation (XDP and TC)
The goal of this project is to develop an Active Learning based Bayesian Geometry Optimizer(ALBGO) using PyTorch and BoTorch for optimizing the conformers locally and globally in internal coordinates, with support for several computational models like force fields, quantum chemistry and ML-based force fields. Bayesian Optimization is a highly effective technique for global optimization of "black box" functions and tuning hyperparameters. Since it does not require gradients, it can efficiently optimize hyper parameters for a Deep neural network or even electronic structure methods without derivatives. The project involves using Bayesian Optimization with an active learning approach to optimize conformers. The major work involves finding the right set of kernels for the Gaussian Process model for different types of molecular variables like Vibrational energy, bond lengths etc. and tuning them. We also an active learning approach to help the algorithm converge towards the solution much more quickly. Finally, we benchmark and compare the performance of our optimizer against other conformer optimization methods in use, like BFGS and gradient-based optimization algorithms. This project has the potential to significantly improve the optimization capabilities of researchers in several fields by reducing the cost of optimization and improving optimization performance. The ALBGO algorithm will be a valuable addition to the optimization landscape, and its PyTorch-based implementation will make it easily accessible to a wide range of users including non-chemists.
This program pairs one or more mentees with an experienced mentor to deliver an AOSP 12 emulator for 64-bit RISC-V. RISC-V International has setup Android SIG and released RISC-V Android github repo as https://github.com/riscv-android-src. Current RVI Android codebase is based on AOSP 10, while the latest AOSP is 12 now. We hope to catch up with latest AOSP 12 codebase, and as part of our plan, an emulator is required first as test and run environment. Deliverables (bullet list of components and the changes expected): - Add RISC-V target in the emulator. - Porting Ranchu virtual board to support RISC-V machine. - Corresponding unit tests implementation - Regression tests pass Note: upon work should be based on AOSP 12. 3. acceptance criteria Acceptance criteria (bullet list with measurable results defined): - Phase I: Virtual peripherals of emulator can work with RISC-V 64bit cores and pass unit tests. - Phase II: Emulator can boot-up with Linux plus basic rootfs w/o GUI for AOSP 12. - Phase III: Emulator can boot-up with Linux plus rootfs w/ GUI for AOSP 12. Note: due to AOSP 12 rootfs is still in developing, a AOSP 10 rootfs from Android SIG repo can be used instead to help verification, but the kernel version should be matched with AOSP 12.
The existing Commons Numbers library for complex types uses collections of complex object instances that incur Java object allocation overhead and is inefficient for iteration and operations on large complex data sets. There are several third party Java libraries for complex math that each have their advantages and disadvantages, but Java developers currently have no single API for Complex operations that can use these libraries at runtime without rewriting their applications This project would provide Java developers with a single Complex API with abstractions that allow for efficient data structures (such as primitive arrays and value types - as proposed by Java Project Valhalla), use of Java 8 language features (Lambdas/Streams) and a Service Provider Interface (SPI) to integrate with existing (JTransforms, JBLAS, EJML) and future third party libraries (Java 17 Vector API, jcuda, aparapi) The project deliverables would include interfaces to represent complex scalar, vector, matrix types and functional interfaces for complex unary and binary operators & functions. The existing methods in Commons Numbers would be refactored as static functions for use as Lambdas with the new API. The JTransforms library will be integrated for supporting operations such as fast Fourier and Discrete Cosine transforms. Optionally, an implementation using Java 17 vector API would be provided for basic operations on complex vectors and matrices. Performance benchmarks comparing different implementations would be published. The deliverables will include complete Pull Requests meeting all Apache Commons Numbers project requirements