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 proposal aims to create a web-based Integrated Development Environment (IDE) specifically for writing and executing SPARQL queries within Tracker. This user-friendly interface will empower developers by allowing them to compose and edit multiline SPARQL queries directly in a code editor, eliminating the need for the traditional terminal approach. Once a query is written, it can be effortlessly executed via the HTTP SPARQL endpoint, and the results will be presented in a visually appealing format, enhancing readability and user experience. By lowering the barrier to entry for newcomers, boosting developer productivity with visual editing, and fostering collaboration through easier query sharing, this web IDE promises to significantly improve the experience for those using libtracker-sparql to interact with RDF databases.
This project aims to improve how Asyncapi objects are visualized in AsyncAPI by introducing a new preview feature. By combining Markdown and MermaidJS Class Diagrams, and flowcharts, users can seamlessly integrate with AsyncAPI schema and Avro (.avsc) files, creating dynamic and interactive representations of object structures. The project focuses on building clear class diagrams, and flowcharts with MermaidJS, connecting entities with channels, schemas, and operations, and providing additional info for a visually intuitive understanding of message payloads in AsyncAPI. I have planned to take the following action points to accomplish this goal: 1. Set up the project by installing all necessary dependencies and organizing the structure. 2. Develop a new Preview Panel resembling the HTML rendering panel in asyncapi-react standalone. 3. Integrate a components folder to facilitate markdown generation for all asyncapi objects, including mermaid diagrams. 4. Implement mermaid support for diagrams and utilize EJS as a template. 5. Introduce a tool for converting HTML to Markdown, such as turndown, to enable export functionality. Additionally, I plan to incorporate flowcharts, Class Diagrams, and display relationships among AsyncAPI specifications objects. A fully-fledged Preview Panel of Markdown for VS-Code will become the outcome of this project.
Protein-ligand interactions play a crucial role in various biological processes, and accurately predicting protein binding sites, where ligand molecules interact, is essential for drug discovery and understanding protein function. Current approaches integrated in DeepChem, such as the use of (geometric) deep learning or molecules fingerprints, mainly focus on predicting protein-ligand binding affinity, and require complex data and/or are computationally expensive. This project focuses integrating ESM-2 (a state-of-the-art protein language model from Hugging Face) with DeepChem, for the purpose of protein binding site prediction. This integration will enable DeepChem library to utilize powerful protein representations learned by ESM-2. A detailed tutorial will be written to provide not only a workflow for streamlined binding site prediction, but a guide that empowers researchers to use protein language models for further tasks within DeepChem. This project broadens DeepChem's toolbox, making it more versatile for the drug discovery community, and ultimately accelerating progress in this area. The main deliverables are: A function for feature extraction using the pre-trained ESM-2 model. Integration of extracted features with binding site information. DeepChem model architecture for protein binding site prediction. Reports for model performance and evaluation metrics. Tutorial documenting the complete workflow, including code, data pre-processing steps, model training details, and visualizations of predicted binding sites (if possible). If time allows, an additional tutorial showcasing the application of ESM-2 protein representations for a different task (e.g., generating peptide binders for target proteins), or implementation of a LoRA wrapper for the ESM-2 model, along with a corresponding tutorial explaining its functionality will be developed. Alternatively, both will be documented as open issues on the DeepChem GitHub repository for future development.
xeus-clang-REPL is a C++ kernel for Jupyter notebooks using clang-REPL as its C++ Interpreter. Cppyy is an automatic, run-time, Python-C++ bindings generator, for calling C++ from Python and Python from C++. Allowing C++ and Python to talk between themselves in a Jupyter notebook will allow users to switch between Python and C++ at will. This means that data analysts can set up their analysis in Python while running the actual analysis in C++. Thus reducing the time to write and debug their analysis pipeline. Initial support of cross talk between the two kernels has been implemented but this only supports passing primitive data types. This project aims to use Cppyy to extend this to support classes and functions.
This proposal entails revamping the existing Processing error message system so that it resembles the P5.js Friendly Error System (FES). The problem is that the current error messages are often vague and not easily understood by beginners. I plan to remedy this by ensuring each error message four components: the original error generated by the JVM, an identification of the problem an explanation of the problem and when possible, a solution to the error. The error messages should convey the severity of the error and in beginner friendly language, explain the cause of the error. The error message should also provide links to relevant documentation to contextualize the issues and also include the original JVM message. Time permitting, additional features such as translation into other languages, a log of previous errors and a button to accept user feedback.
The main goal for this project is to improve the speed of STARDIS, a Python library that generates synthetic spectra for stars. An easy way to accomplish this quickly is to add Numba JIT compilation. Because this can be accomplished so rapidly, a next goal would be to reimplement parts of STARDIS with C/C++ or Cython extensions. This project proposal therefore consists of four implementation phases, the first pair using Numba and the second pair using C/C++ or Cython extensions, with each pair consisting of a CUDA and a Non-CUDA implementation. I intend to make these improvements incrementally and systematically. I will also benchmark the performance before and after each time I reimplement portions of the STARDIS codebase to both understand how much speed was gained and prioritize what to focus on in each next step.
My project is a development of 3 computer vision models: 1. A model for workflow classification; 2. A model for medical equipment detection; 3. A model for scene segmentation (segmenting organs and surgical Tools); NB: I have found out that there is a lack of VR medical imaginary datasets. That is why I suggest to use domain adaptation technique for developing ML models. In other words, I suggest to compare two approach: transforming ordinary images to make them similar to VR images, transforming VR images to adopt them to the original data domain.
The project aims to implement a “Perfect” version of ARP and NDP which produce caches that contain all needed IP address–MAC address mapping. ARP and NDP are sometimes intrusive in high-level testing, it will introduce unexpected noise to the simulation (unwanted delays, packet drops, etc.). Perfect ARP/NDP can ensure every ARP/NDP look-up hits the cache so that no ARP messages or Neighbor discovery messages will be generated.
The CHAOSS community develops metrics, practices, and software for measuring open source software community health and sustainability. Augur and Grimoirelab are two powerful open source community health analytics projects supporting the CHAOSS mission. In particular, each has implementation of select metrics based on an expanding set of implementation-agnostic metric definitions associated with various focus areas. The CHAOSS Metrics Model Working group defines metric models, which integrate multiple CHAOSS metrics in a way that makes it easy for end users such as community managers to get a more comprehensive measure of an open source community. Currently, Conversion Rate can be defined as a metric or metric model. It measures the rates at which new contributors to an open source project move through the "contributor funnel" toward sustained contribution and/or community maintainership. There is no implementation of the Conversion Rate metric or metric model in CHAOSS software yet. This project aims to build a novel implementation of Conversion Rate as a metric model that is based on a minimum number of atomic metrics and has maximum reuse of existing implemented metrics as well as common metric model calculation code supporting all types of conversion rates. A simple config file based UI for entering parameters and filters by the users is all it takes to run the metric model. New metrics will be implemented first in Jupyter Notebook as reference code and can later migrate into Grimoirelab backend (for sharing with future new metric models or reports) along with data collection and enrichment extensions. The Metric Model calculation code and methods, and a common visualization interface will be also implemented in Jupyter Notebook, followed by a deployment with OpenSearch Dashboards visualization.
The Flutter Community provides several packages to the community and pub. dev that all differ in regards to maintenance requirements. The Flutter Community admins struggle to keep up with all of the changes, releases, changelogs, and activities on all packages. To solve this, we are looking to implement a Flutter Community Dashboard that assists admins by rounding up and providing the admins with information regarding issues, latest activities on repositories, maintainers, level of access and implementing a trigger to build and deploy to pub. dev, and more. The set of deliverables are as follows: 1. The flutter frontend 2. Firebase Backend 3. AI tool 4. Testing 5. Documentation
<p>This project starts the transition of Destination: Sol systems from OOP design to Entity-Component-System architecture, using the new Gestalt library. The systems that will be converted will help for future changes as well.</p>
<p>In the past two years since the projects around decoupling Open Event’s frontend and backend began, significant progress has been made in developing the new Frontend and an API centric backend. However, the entire system in its current state is not yet ready to go into production. Along with minor bugs, there are areas like ticket sales, orders and role invites which require a substantial amount of work before the system becomes stable enough to act as an independent product which can be marketed to other Open Source Organisations. Eventyay is FOSSASIA’s production deployment of Open Event. To replace the stable legacy version with the new system will require several code related as well as devOps configurations. In my GSoC project, I intend to take the project to a stable production ready state with the exact details outlined in the proposal which follows.</p>
<p>Firefox Profiler is a tool which visualizes performance data recorded from various performance analysis tools, which helps us to have an insight into our app’s responsiveness, Javascript and layout performance. By using it efficiently we can optimize our app in terms of performance. Currently, it supports Gecko, chrome, and perf(Linux) profile formats. This project will provide support for visualizing profiles from Instruments which is a powerful and flexible performance-analysis and testing tool that’s part of the Xcode toolset.</p>
<p>This project is of type Improving an existing tool that includes cleaning up the existing codebase and adding the process injection support for Linux.</p>
<p><strong>Meaningful Adversarial Examples for Natural Language Models</strong></p> <p>A project to create adversarial examples and resulting counterfactuals for text classifiers using the relations in the word embedding vector space. This allows for meaningful alterations to be made in the input documents to test a model for biases. What would happen if the subject of this document was female instead of male? If it was a person of color instead of being white? How would a state of the art model change its results when such changes are made?</p> <p>This project means to address these questions by creating a framework that allows for the testing against such biases as well as the creation of augmented datasets to dissuade their development.</p>
<p>Security Knowledge Framework (SKF) is a tool that is used as a guide for building and verifying secure software.It can also be used to train developers about application security. The OWASP Security Knowledge Framework is an expert system web-application that uses the OWASP Application Security Verification Standard and other resources. It can be used to support developers in pre-development (security by design) as well as after code is released (OWASP ASVS Level 1-3). Chatbots are software agents that interact with the user in a conversation. A chatbot is a service which is provided by websites so that users can easily able to fetch information interactively. They can reach out to a large audience on messaging apps and be more effective. A chatbot provides a speedy and quick response and available around the clock. Such programs are often designed to convincingly simulate how a human would behave as a conversational partner. Chatbot will be an attempt to reduce the pain of the user and will help users in finding solutions to their problems and thus improving the security of code and infrastructure. This will be integrated into various chat systems to make it easier to use.</p>
<h3>Problem</h3> <p>As of today, CancerDiscover has a not-so-easy build and workflow for users to conduct microarray experiments. Moreover, the current setup requires users to manually download datasets and at the same time, separately label them. Users have no visual analysis provided at any given time during the course of the experiment. Moreover, users are also limited to use the default parameters for each classifier, thus limiting a user to build more efficient prediction models. Finally, the overall workflow is poorly documented for installation and usage.</p> <h3>Solution</h3> <p><strong>candis</strong> - A minimalistic clean Graphical User Interface integrated with the current command-line tool will not only provide a smooth build and workflow for an experiment setup, but also provide <strong>remote downloading for data sets</strong>, <strong>quality control visualisations</strong> and <strong>user-defined parameters</strong> during analysis. A modular framework will also provide future extensions for more techniques. Users will also have access to a well-documented manual that eases the overall use of the proposed software. The current ongoing development of this application can be viewed at <a href="https://github.com/achillesrasquinha/candis" target="_blank">github.com/achillesrasquinha/candis</a></p>
<p>NetJSON is a great work attracted some interest from around the world, but there are a lot of defects. And I’m a front-end developer and now focus on Data Visualization, so I want to contribute to NetJSON. In my proposal, I come up with my idea and list some tasks and schedules.</p>
<p>Neural Networks are one of the most breakthrough techniques nowadays. The goal of this project is to perform a radical update to Octave nnet package in order to keep pace with the times. Other open-source projects will be used, like Tensorflow. This will allow to guarantee a continuous updating on neural networks improvement and leading to a greater focus on Octave interface. The tendency to open-researching is strong in the deep learning field, where even the biggest companies release their frameworks and open their code. In this sense, a project on the Neural Networks package, where Octave can coexist with Tensorflow, let us exploit their synergy and reach fast consistent goals.</p>
<p>Mitmweb is now shipped with our releases, supporting most of the fundamental features. However, some important features have not been brought to mitmweb yet. My plan for this summer is to make mitmweb have equally powerful functions as our console interface, and also take the advantage of its flexible Web interface, bringing some awesome visualization features to it.</p>
<p>Educating an amateur or an avid Android user with the threats they can face on their Droid and protecting it by building a <em>Knowledge Base for <a href="https://www.owasp.org/index.php/OWASP_SeraphimDroid_Project" target="_blank">Seraphimdroid</a></em> providing User with Articles based on Security and Threat Detection.</p>
The Flexible Network Tester (Flent) is an industry-standard tool for evaluating Bufferbloat and network performance. However, benchmarking simulated networks in ns-3 currently requires researchers to rely on external, error-prone parsing scripts to translate simulator events into Flent-compatible data. This project solves this disconnect by natively integrating the Flent Application API into the ns-3 mainline. The proposed solution involves modernizing a legacy C++ wrapper, eliminating artificial queue constraints used in prior proof-of-concepts, and refining the linear interpolation logic to accurately translate discrete ns-3 trace callbacks into strict periodic data points. A critical phase of the project involves scientific validation. comparing the simulated ns-3 outputs against real-world Linux hardware benchmarks (using tc and ss) to guarantee mathematical and statistical accuracy. Deliverables: 1) A robust, memory-safe FlentHelper C++ API that allows users to seamlessly configure tests and directly output visualization-ready .flent JSON files. 2) A scientific validation report proving the parity between the simulated network metrics and physical Linux network namespaces. 3) Expanded support for complex multi-flow Bufferbloat tests (including RRUL, Best Effort, and VoIP). 4) Comprehensive user documentation and automated example scripts merged into the ns-3-dev mainline.
This project successfully developed two AI-powered tools to enhance software quality at Eclipse Adoptium. The first, GlitchWitcher, implements the REPD (Reconstruction Error Probability Distribution) model, using an autoencoder for supervised anomaly detection to proactively predict software defects. The project's primary deliverable evolved into VitAI, an advanced, modular multi-agent AI assistant for interactive test triage. VitAI's architecture features a custom MCP (Model Context Protocol) server for providing an interface to interact with a specialized agent and a Retrieval-Augmented Generation (RAG) system. The RAG system provides deep, context-aware responses by querying a vector database of project documentation, issues, and build data. This work was supported by automated data pipelines and is showcased in a live interactive demo.
The HITEMP CO₂ spectroscopic database is extremely large and inefficient to work with. The distributed file is about 6 GB when compressed, but expands to nearly 50 GB upon decompression. The existing workflow requires fully decompressing and batch-parsing the entire file, an operation that takes close to 2.5 hours and consumes significant disk I/O, memory, and network bandwidth. This full-decompress/parse approach forces users to rely on large, high-speed storage, makes quick exploratory analysis or iterative development impractical, and wastes both bandwidth and time when only a small subset of the data is actually needed. This project addressed the problem by implementing a partial download mechanism, where only the required data chunks are downloaded, decompressed, and parsed based on user queries. The parsed results are then cached for reuse. For performance, the cache parsing was accelerated using a C++ SIMD (Single Instruction, Multiple Data) parser optimized for AVX2 architectures, while for other architectures the system falls back to an optimized Python vectorized parser.