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.
CAR T-cell therapy is a form of cancer immunotherapy that engineers a patient’s T cells to recognize and eliminate malignant cells. Although highly effective in leukemias and other hematological cancers, this therapy faces significant challenges in solid tumors due to the complex and heterogeneous tumor microenvironment. CARTopiaX is an advanced agent-based model developed to address this challenge, using the mathematical framework proposed in the Nature paper “In silico study of heterogeneous tumour-derived organoid response to CAR T-cell therapy,” successfully replicating its core results. Built on BioDynaMo, a high-performance, open-source platform for large-scale and modular biological modeling, CARTopiaX enables detailed exploration of complex biological interactions, hypothesis testing, and data-driven discovery within solid tumor microenvironments. The project achieved major milestones, including simulations that run more than twice as fast as previous model, allowing rapid scenario exploration and robust hypothesis validation; high-quality, well-structured, and maintainable C++ code developed following modern software engineering principles; and a scalable, modular, and extensible architecture that fosters collaboration, customization, and the continuous evolution of an open-source ecosystem. Altogether, this work represents a meaningful advancement in computational biology, providing researchers with a powerful tool to investigate CAR T-cell dynamics in solid tumor and accelerating scientific discovery while reducing the time and cost associated with experimental wet-lab research.
The 2D Arrangements package in CGAL provides an efficient and extensible framework for representing and manipulating arrangements induced by geometric objects. The existing visualization utilities are useful but exhibit several limitations: inefficient rendering procedures of faces with holes, lack of support for unbounded curves and faces, and inability to correctly render faces on curved surfaces. This project implements a general renderer for arrangements that integrates with the Aos2 framework and addresses those limitations. The new renderer provides on-demand approximation of x-monotone curves; uses a customized face triangulator to efficiently produce meshes; and leverages tiling and caching to make interactive navigation responsive.
This project aims to develop a cross-platform application for Mankala using Qt and QML, extending the capabilities of the existing MankalaEngine maintained by the KDE Community. The application will feature a responsive, touch-friendly interface and support both local gameplay modes and real-time multiplayer using the Extensible Messaging and Presence Protocol. By combining a modern UI with networked communication, the project seeks to bring traditional Mankala gameplay to mobile devices while promoting open-source tools and accessibility.
Problem: While Large Language Models (LLMs) like ChatGPT can generate R code, they often lack precision when answering questions about third-party R packages or contributing to the R language itself. This can limit their usefulness for R users, particularly for new contributors seeking to understand the R core or engage in package development. Furthermore, many of these AI tools are proprietary or resource-intensive, excluding users with limited hardware or funding. Solution: ChatR proposes a specialized R chatbot that is lightweight, locally runnable (even without a GPU), and customized to provide reliable support on R packages, documentation, and contribution practices. The project will use Retrieval-Augmented Generation (RAG), prompt engineering, and a lightweight open-source LLM (via Ollama and llama3.2:3b-instruct) to deliver targeted responses. It will be delivered as an R package with both CLI and Shiny UI interfaces. Deliverables: An R package wrapping the chatbot and customizable prompts Local model integration using Ollama and ellmer RAG-based indexing of documentation (e.g., CRAN, Writing R Extensions) A Shiny widget interface for interactive usage in RStudio Documentation, test suite, and demo applications This project will significantly support learners, developers, and contributors by democratizing access to reliable AI-based R support and onboarding tools.
The AI-Powered Media Caption Generator is a smart Drupal module designed to automatically generate engaging and customizable captions for uploaded media using artificial intelligence. It leverages Google Vision API for image understanding and OpenAI along with Hugging Face Transformers for natural language captioning. Users can tailor the captions by choosing the tone, length (0–2000 characters), keywords, and emoji usage. A Python-based backend (using FastAPI or Flask) powers the AI caption generation and offers API support for optional integration with Drupal. The user interface will be built directly within Drupal to ensure a seamless media management and captioning experience.
Problem: Symbolic regression is crucial for discovering underlying physical laws from data, but traditional methods are often computationally expensive or lack generalization. Current approaches struggle with efficiency and adaptability across diverse scientific datasets. Solution: This project aims to develop a foundation model for symbolic regression by integrating transformer-based architectures (e.g., SymbolicGPT) with evolutionary algorithms and learned concept libraries (LASR). The model will leverage large-scale pretraining and fine-tuning to generalize across mathematical and physical datasets, combining the strengths of language models and evolutionary search for interpretable, efficient equation discovery. Deliverables: A transformer-based symbolic regression model with mathematical priors and curriculum learning. Integration of a learned concept library for reusable abstractions. Benchmarks against SOTA models. Optimized, modular code for seamless LLM integration and open-source deployment.
Currently, ceph-devstack runs a testnode container with only one OSD per node using a loop block created on the host system as a storage device. To be closer to a production-like environment, it is important to make ceph-devstack run many OSD per testnode. To do that we need to : enable support for arbitrary number of OSDs and define size of storage devices. The deliverable will be a new version of ceph-devstack with listed features.
Traditionally, brain activity has been analyzed independently from peripheral physiological measurements like the electrocardiogram (ECG), but our understanding of brain-heart interactions (BHI) has significantly evolved since then: we now know that not only does the brain modulate the heart but surprisingly the heart exerts a powerful influence on the brain. For example, the timing of a learning task relative to the cycle of the heartbeat modulates its event-related potential (ERP), and heart-beats interact with activity in the insula, an area critically involved in internal monitoring. However, despite this increased interest in BHI in the neuroscientific community, there is a lack of well-documented tool, that incorporates much of the modern BHI identification techniques, treats sensitively ECG artifacts, and furthermore complements modern brain connectivity analysis. BHI studies point to a much greater complexity in neural signals that current connectivity packages fail to account for, such as recent work pointing to the modulating of brain oscillations by respiration. As such, this project has two main purposes: extract BHI and direct respiratory modulation of the brain and build a brain connectivity tool that accounts for these confounding measures, built in the Python MNE environment to complement traditional data analysis pipelines. Our analysis functions will furthermore be validated through tutorial-like experiments, written as Jupyter notebooks on open datasets, and we hope that the results I show will convince the scientific audience of the importance of confounding peripheral measures in neural data. The minimal set of deliverables include: individual analysis functions for peripheral physiological signals, connectivity measures between peripheral and neural signals, and brain connectivity measures, both regular, and conditioned on peripheral physiological signals to remove their effect, and experiments demonstrating these tools on open datasets.
Diffusion models have experienced rapid growth in usability, availability, and research. The classical algorithm consists of two main parts: a forward diffusion process and a learned denoising step. The forward diffusion process discretely applies noise to an image until it is unrecognizable. The denoising process reverses the noise, predicting the original image. Quantum techniques, such as parametric quantum circuits, could be applied to both parts to create a fully quantum model that could run on a quantum computer, speeding up training time. This model would be trained on multiple high energy physics datasets, such as the quark and gluon dataset for generating quark and gluon jets, alongside a classical diffusion model, and the results could be evaluated taking into account resources, time, and quality. Furthermore, a mathematically-driven approach would provide the theoretical foundations of quantum diffusion models in addition to experimental results.
This project extends capa, FLARE's open-source capability detection tool, with Android dynamic analysis using Frida instrumentation. The implementation automates the complete Frida workflow from template-driven script generation to feature extraction. This brings capa capability detection to the broader Android dynamic malware analysis community.
This project proposes integrating ACTINN, a neural network for automated cell type identification in single-cell RNA sequencing (scRNA-seq) data, into the DeepChem framework. Integrating ACTINN into DeepChem would mark the framework's inaugural inclusion of a single-cell deep learning model, significantly expanding its capabilities in the burgeoning field of single-cell analysis. By incorporating ACTINN, DeepChem can offer researchers a powerful tool for automated cell type identification, streamlining workflows in single-cell analysis and fostering deeper insights into cellular heterogeneity.
Current Frontier LLMs are really bad at assisting with writing JAX code due to the sparse resources spread across multiple different forums and platforms which are often inacessible/unscrapeable (such as discord) by conventional search engine indexers or web scrapers. Thus they usually do not make it into the final pretraining datasets, hurting frontier models' performance on those frameworks. I want to fine-tune OSS models on JAX code, where the data is manually scraped/collected by hand from diverse sources like YT talks, GitHub discussions, Books & Papers and even XLA HLO dumps to enhance the models' understanding of the compiler internals and improve debugging capabilities as well as better guide the developers when dealing with the internals. Another key focus would be incorporating commonly-used popular libraries like Equinox, Optax and Scalax as well because current SOTA LLMs are not familiar with these (relatively) niche but handy libraries and thus prove to be less helpful and prone to hallucinating components of the ecosystem that don't exist. This pretrained model will be available externally through an API or a CLI interface like Aider/Claude Code styled wherein it'd be accessible to everyone regardless of their development environment or IDE/Editor. I would also experiment with new ideas such as integrating type-annotations, Array and PyTree shape annotations and packaging other auxiliary information embedded in the AST to provide further context to the model apart from the raw code itself.
Build a service to simplify the process of onboarding new packages to Fedora with a pull-request based workflow that integrates seamlessly with modern Git-forges like Github and Gitlab by automating key steps, creating a valid spec file, build testing, and review. Also, it reduces the workload for the reviewer by carrying out a set of common checks used in package review with rpmlint and rpminspect. Acts as a bridge between the Bugzilla-based review process and git workflows; users would be able to get feedback from both tools and more experienced packagers right within a PR-based workflow.
The current OpenMRS performance testing project provides a foundational skeleton with some initial scenarios already implemented. This proposal aims to enhance that framework by making it more comprehensive, scalable, and user-friendly. Key improvements include modularizing the backend structure to promote reusability, introducing a flexible LoadShare JSON-based configuration system to simplify test setups, and expanding coverage to include additional user personas and real-world scenarios that represent a wide range of application functionalities. The project will also address data duplication issues and introduce support for scalable, cloud-based test execution via AWS. To ensure long-term sustainability and ease of contribution, detailed documentation and an onboarding guide for new contributors will also be provided.
As the number of non-x86 Linux-capable devices grows rapidly (especially ARM64 laptops, phones, and tablets), the current approach of providing device-specific Debian packages for configuration tweaks doesn't scale efficiently. This project aims to develop a flexible tweaks management service called "Tweakster" that will identify the device it's running on, select the appropriate tweaks based on configuration files, and dynamically install them to the system. This solution will unify device detection, streamline configuration deployment, and ultimately ease support for new devices in Debian.
This project aims to enhance the security of WasmEdge plug-ins by exporting key WASI APIs, thereby ensuring a robust and secure virtual filesystem sandbox for file operations. With the rapid growth of AI applications, WasmEdge plug-ins have become indispensable for tasks such as natural language processing, image synthesis, and speech recognition. However, direct file system access in current implementations exposes critical security risks. To address this, our proposal focuses on designing and implementing a dedicated filesystem sandbox API that restricts file read/write operations to pre-authorized directories. The initial phase will concentrate on the WASI-NN plug-in and other simpler file I/O functions, with potential future enhancements to more complex applications like Stable Diffusion’s image-loading functionality. Our comprehensive plan includes an in-depth study of the WasmEdge sandbox architecture, API design and integration, modification of internal plugin call patterns, and the development of rigorous test cases to validate sandbox effectiveness. Detailed documentation and developer guidelines will be prepared to facilitate secure plugin development. With a project timeline from June 2 to September 1, this initiative will leverage my background in virtualization, parallel computing and my past contributions to WasmEdge. The expected outcome is a significant improvement in the security and isolation of file operations in WasmEdge plug-ins, paving the way for safer and more reliable deployment of AI-driven applications.
Currently, most GRASS tools produce data in plain text, which forces users to write custom parsing code when processing output in Python. This project aims to leverage the recently integrated Parson library to expand JSON output capabilities across more GRASS tools. By collaborating with mentors, I plan to finalise a robust and consistent JSON output structure, building upon and improving the implementation introduced during the last GSoC. Additionally, I will work on introducing SHELL and CSV output formats where applicable, providing users with more flexible options. Each updated tool will support a user-selectable output format—plain text, JSON, SHELL, or CSV. I will develop Python test cases to ensure the reliability of the outputs, provide thorough documentation with sample outputs, and create practical demonstrations—such as reading JSON data into pandas—to showcase how these enhancements streamline data processing. This initiative will significantly improve the usability and flexibility of GRASS tools, making them more accessible for data science workflows.
With rtcstats, it is possible to gather a lot of information about meeting quality and logs. However, it is difficult for self-hosting users to analyze and monitor meetings using rtcstats in Jitsi Meet. The goal of this project is to make it easier for self-hosting users to deploy and use rtcstats with Jitsi Meet. To achieve this, I propose to add rtcstats Docker containers to docker-jitsi-meet, with support for both AWS and MongoDB integration options.
This project aims to enhance the DrTest tool in Pharo by improving its usability, functionality, and performance. DrTest is a critical resource for developers to test and analyze code coverage, but there is room for improvement, particularly in the areas of user experience, compatibility, and fault location. Through this project, I will implement a range of improvements, including enhancements to the code coverage and test comment visualization, optimizations to the performance plugin, and the development of a new fault location plugin. By the end of this project, the DrTest tool will be more user-friendly, compatible with the latest version of Pharo, and capable of providing more accurate and detailed test results, benefiting developers and contributing to the Pharo open-source community.
This project enhances the console output experience for the Swift Testing framework by designing and implementing a new, two-phase console reporter. This architecture provides both real-time feedback during test execution (the "Live Phase") and concludes with a comprehensive, structured report (the "Summary Phase"). The primary focus during this GSoC project was the implementation of the Summary Phase, which includes: - A rich Hierarchical Summary that visualizes the relationship between test suites and individual tests. - A dedicated Detailed Failure Report providing clear, actionable information for debugging. - Intelligent cross-platform support, with an ASCII fallback for terminals with limited Unicode compatibility. Architecturally, the reporter was refactored to consume a serialization-based event stream (ABI.EncodedEvent). This was a significant technical pivot that decouples the reporter from the test runner, preparing it for future integration into an out-of-process "harness". The final deliverable is a robust, experimental implementation available behind a feature flag, with a clear roadmap for completing the Live Phase post-GSoC.
Graphs are powerful tools for understanding relationships and structures — from social media connections to brain networks. Often, we want to study whether these structures exhibit unusual features. To do so, we compare the graph in question to a "baseline" or "generic" graph, called a null model; this gives us a point of reference to identify whether the features we see are truly unusual or simply a result of random chance. As such, the goal of this project is to expand the igraph library's ability to work with null models. Given a set of characteristics about a graph, we want to make it more flexible to 1) check whether a graph with these characteristics exist (graphicality), 2) create a graph with these characteristics (construction), and 3) derive other graphs that share the same characteristics (rewiring). With more flexible and performant tools for working with null models, igraph can better support the network science underpinning so many scientific domains.
This proposal focuses on improving the Implementer Tools in OpenMRS 3 by addressing current limitations and adding key features. The project aims to support object editing in config fields, enable UI-based translation overrides, improve extension handling, and add privilege-based display conditions. It also proposes implementing Carbon React-based dark mode, a color picker for branding, server-side configuration saving, and fixing UI inconsistencies. These changes are aimed at making the tool more complete and easier to use for OpenMRS implementers.
This project aims to enhance LLDB's disassembler by annotating machine instructions with source-level variable information, such as variable locations and lifetimes, based on debug data like DWARF. Currently, LLDB’s disassembler outputs only low-level instructions, requiring users to manually infer where source variables are located. By enriching disassembly output with variable annotations (e.g., which register or constant a variable is stored in), this project will make debugging optimized and low-level code significantly easier. The solution involves extending LLDB’s disassembly printing pipeline to query live variables at each instruction address, limited to variables that reside in CPU registers or are represented as constants, ensuring efficiency and clarity. Deliverables include: Annotated disassembly output in the LLDB command-line interface. Full test coverage against optimized and unoptimized binaries. Documentation and usage examples for developers and users. This work will be designed to be debug information format-agnostic wherever possible, making it extensible across formats like DWARF and PDB.
Rocket.Chat’s Message Composer currently displays raw Markdown syntax and emoji shortcodes while composing a message, only applying formatting after the message is sent. This impacts readability and usability, as users must interpret raw syntax instead of seeing the final formatted output. This project will introduce real-time Markdown rendering and native emoji support in the Message Composer. Users will be able to see bold, italic, and other formatted text as they type, along with correctly rendered emojis. Additionally, the project will provide a proof-of-concept for migrating from Rocket.Chat’s third-party emoji pack to native emoji support. Key Deliverables: 1. MVP implementation of real-time Markdown rendering in the Message Composer. 2. Native emoji support, replacing the existing third-party emoji pack. 3. Support for mentions with a defined style, ensuring visually distinct tags. 4. Text sanitization to maintain security and prevent unintended behavior. 5. Help tooltip for Markdown syntax, improving accessibility for new users.