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.
KDE is one of the largest open-source communities, offering opportunities in the field of development, design, documentation, translation and mentorship. However, the current onboarding experience is very fragmented, the entry points are spread across various platforms which often leaves new contributors asking "Where do I even start?". This project aims to build join.kde.org as KDE's primary contributor entry point and central hub, routing users to the right resource. The site will allow users to find their own place in open source software based on their interest and it will allow experienced contributors to contribute directly into projects based on their skillset. The site will be organized into clear sections: Add, Learn, Divulge, Work on a Project, Read, Explore, Meet, and Suggest. Built using Hugo for static site generation, Deliverables include a fully responsive website with interest-based navigation, structured contributor pathway cards for all contribution types, mentorship program overviews, a KDE Networks map with setup instructions, and complete site maintenance documentation. This project directly aligns with KDE’s goal: "KDE Needs You" , which aims to bring more contributors into the community and increase the retention for the said contributors.
With WASI-NN plugins, WasmEdge is well-suited for running AI applications. However, AI applications are more than just the model. The application must pre-process data (such as images, audio and video) into TFLite / PyTorch formats, and convert the inference results back into application data in post-processing. Here are some examples: * The [mediapipe-rs](https://github.com/WasmEdge/mediapipe-rs) project provides a Rust SDK to build applications for the mediapipe AI models. * The [llama2.c](https://github.com/karpathy/llama2.c) application is [compiled to Wasm and runs in WasmEdge](https://medium.com/@michaelyuan_88928/running-llama2-c-in-wasmedge-15291795c470) to generate text using the [llama2](https://ai.meta.com/llama/) models. In this project, we would like to build a Rust SDK to support applications on the [YOLO models](https://pjreddie.com/darknet/yolo/). - Expected Outcome: - A Rust SDK that implements the pre-processing and post-processing functions required for the YOLO models. Those functions are implemented in OpenCV and Python in the official YOLO release. - Both image and video inputs should be supported. - Examples and documentation should be provided. - Recommended Skills: - OpenCV - Rust - Tensorflow / Pytorch - WebAssembly
ProLIF, a tool for identifying protein-molecule interactions in molecular dynamics trajectories, lacks a straightforward method for evaluating hydrogen bonds when only heavy atoms are present. Many users usually compare experimental and computational structures without explicit hydrogens, but the existing protonation tools are cumbersome and error-prone for beginner-level programming users. This proposal introduces an "implicit hydrogen bond (H-bond) interaction method" directly using heavy atom positions to detect H-bonds. The goal is to strike a balance between efficiency and accuracy and increase ProLIF's usability. The method will leverage distance-based calculations with geometrical constraints, similar to Mol* and Chimera, and incorporate a confidence score based on AutoDock Vina's hydrogen bond term. Standardizing residue names from various force fields (CHARMM, AMBER, GROMOS, OPLS-AA) and assigning their associated protonation/hybridization states will be crucial for the new "Protein helper function” before the H-bond detection. Lastly, I plan to use the PINDER and PLINDER datasets (protein-protein and protein-ligand interactions, respectively) to validate the implicit H-bond interaction method by comparing the results from the standard H-bond method.
Virtual niche simulations are a powerful tool for testing ecological theory, and nicheR provides an integrated, R-native framework for ellipsoid-based virtual niche construction, prediction, and data generation. This project will deliver a Shiny graphical user interface for nicheR, making these tools accessible to researchers regardless of their programming background. The app will guide users through a complete virtual niche workflow across six tabs: data input, niche design, prediction, bias preparation, data sampling, and reproducibility. Throughout, contextual messages will explain the ecological meaning of key parameter choices, ensuring users understand the theory behind what they are building rather than just clicking through steps. A key feature is that every interactive session generates a fully reproducible R script, so users can transition seamlessly from the GUI to scripted workflows. Deliverables include a fully functional Shiny app packaged within nicheR with a run_app() launcher, test cases for each module, and two vignettes. By lowering the technical barriers to ellipsoid-based niche modeling, this project expands access to rigorous, theory-driven tools for ecologists, conservation practitioners, and students across the R community.
<h3>TumorComparer, updated version</h3> <p>The TumorComparer is a computational method for the comparison of different cancer types with cancer cell lines by their cellular profile. This comparison allows finding the closest cell lines for a selected cancer type by molecular profile as well as to detect outliers.</p> <p>The main objectives of the project are:</p> <ul> <li>Expand the package to include new data types</li> <li>Create patient to patient similarity examples on R shiny based platform</li> <li>Provide a network visualization for correlated samples and cell lines</li> </ul> <p>Further updates for the package are:</p> <ul> <li>Implement a function to perform comparison for separate gene sets and make the graphical interface of the function for shiny application</li> <li>Update R shiny application to have better error handling, improved event observers for optimal app performance, and interactive documentation</li> </ul> <p>Finally, an updated version of the package will be capable to analyze new omics data types as well as perform comparisons for separate gene sets. R shiny application will be more optimized and user-friendly.</p>
LLM assisted coding is one of the most promising application areas for modern AI. It will also have profound impact on open source software development. As many projects have demonstrated, "feeding" an LLM with contents from a GitHub repo will make it better at understanding coding tasks for this project. In this project, we will take a modern approach to build LLM agents based on LlamaEdge / WasmEdge, and supplement it with deep knowledge of open source projects on GitHub. The goal is for the agent to answer questions and solve problems raised by the open source community. Expected Outcome: * Build an automated tool to extract and process all files in a repo. That includes source code and docs. * develop a GitHub bot to capture all change files and update the knowledge base in real time. * generate a summary for each file (using an LLM) and supplement with its file path and other meta data. * create a vector database with the summary and original text. The vector is computed from the summary to improve search efficiency. * Run an LLM agent node with the RAG database from the repo. * Create a GitHub bot that can read new issues and respond with either an answer or a coding suggestion based on the content inside the repo. * Evaluate the answer quality.
This project aims to enhance the SANTE search API of DBpedia, a popular knowledge graph that provides structured data extracted from Wikipedia. The SANTE search API is an important component of DBpedia that enables users to search and retrieve information from the knowledge graph using natural language queries. However, like any search engine, the performance of the API can be improved by optimising the underlying technology, data quality, and user experience. Therefore, this project will focus on enhancing the search API by incorporating various techniques such as data quality improvement, indexing optimisation, query parsing enhancement, incorporation of external knowledge sources, relevance feedback, and the use of machine learning techniques. These enhancements will improve the accuracy, efficiency, and usability of the SANTE search API, making it a more valuable tool for knowledge discovery and information retrieval. There are several knowledge bases currently published in RDF format and exploring this information is still challenging for non-RDF neither SPARQL users. DBpedia-Search aims at facilitating information navigation, exploration, and seeking through DBpedia Knowledge base with natural language queries. This GSoC project consists of enhancing DBpedia Search APIs by including tests, benchmarks, and additional functionalities.
CrashDragon plays a critical role in transforming VLC crash reports into actionable fixes, but current gaps in API consistency, auth-sensitive behavior, and frontend completeness introduce friction in triage and integration workflows. This project is a continuation of prior work and focuses on improving reliability without breaking existing functionality. The approach includes: Reviewing current API and frontend behavior to identify inconsistencies between public routes and /api/v1. Improving the Go backend by standardizing API response contracts, tightening validation, and hardening auth-sensitive mutation paths while preserving backward compatibility. Completing missing frontend surfaces and aligning Vue service-layer logic with typed API contracts to eliminate fragile response handling. The project will be delivered through incremental, review-driven changes with strong regression testing and CI validation to ensure stability. Deliverables: Consistent and well-defined /api/v1 API behavior with improved validation and error handling. Hardened authentication and mutation route reliability. Completed frontend views (stats, symfiles) with contract-aligned data handling. Expanded backend regression tests and improved documentation. Final implementation report and follow-up issue roadmap.
<p>Casbin is an authorization library that extends its features to implement Access Control Lists, Role-Based Access Control, and Attribute-Based Access Control models in various programming languages to its clients. Casbin's Core Engine is written in GoLang. Casbin-CPP has obvious benefits of speed and efficiency compared to its implementation in other languages and thus, benchmarking is vital for the project to stand out from the rest. Python is the most versatile as well as the most used programming language and has huge community support. Casbin-CPP has the potential to support new PyCasbin to compound the benefits of both languages through language bindings and extension libraries. Currently, the project uses Microsoft Unit Testing Framework for C++ for testing and Microsoft’s Azure DevOps pipelines for CI. CTest is truly cross-platform and can be configured using GitHub Actions for consistent and better CI.</p> <p>Project Ideas are as follows:</p> <ul> <li>Modernizing the project with C++17 standard and Google’s benchmarking tool</li> <li>Implement Python bindings for Casbin-CPP using pybind11 library</li> <li>Implement testing based on CTest and set up workflows for Continuous Integration through GitHub Actions</li> </ul>
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.
Android Client is a mobile application that allows bank staff field officers to keep track of clients, centers, groups, loan accounts, saving accounts, and other critical information. The project aims to upgrade the Mifos Android client application by updating it to the latest dependencies and rewriting it to consume the Mifos Fineract SDK using coroutines and flows. The Android client will become the first Mifos app to utilize the Fineract SDK, thereby reducing redundant network layer code. The upgrade will involve two main migrations: transitioning from XML to Jetpack Compose and supporting a multi-module MVVM architecture organized by feature-wise modules. Additionally, the project will include supporting Kotlin Multiplatform (KMP). The upgrade will also encompass implementing unit and integration testing for features and upgrading the CI/CD pipeline for KMP and Google Play Store release pipelines. Integrating the Google Play Store API will streamline the release flow, leading to a more stable and error-free codebase, faster build times, and an improved developer experience. These changes will also facilitate smoother release management and upstream contributions, ultimately reducing the time required for upgrades.
This project aims to use self-hosted runners to run GPU-intensive tasks like LLM blueprint or (planned) AI Playground. The necessary infra is provided by Oracle, plan is to use Oracle Kubernetes Engine (OKE) with NVIDIA GPUs for this task. Any code or sample that requires GPU-intensive resources will be transferred to OKE infra instead of generic GitHub infra for faster and more efficient execution. For now, the idea is to have a specific policy that whenever any Jupyter Notebook code will be added to a trainer/examples/pytorch/** folder (e.g., in trainer/example/pytorch/image-generation/sample.ipynb), that action is transferred to OKE infra by the GitHub self runner. For security reasons, this process will require manual approval from one of the maintainers to trigger the self-runner build. I will set up the GitHub workflow to monitor changes in the respective folder. Once approved, the CI action will execute the code using the GitHub self-runner on the OKE infrastructure. Additionally, we will set up a dashboard for monitoring and metrics to understand usage patterns and identify bottlenecks. The scope of this project is set up on OKE, but theoretically, this is platform-agnostic; it can be deployed on any Kubernetes cluster with sufficient GPU resources.
Federated Learning (FL) is a machine learning (ML) approach that allows models to be trained collaboratively and distributedly without sharing individual data points. WebGPU, a modern web standard and API, provides low-level, high-performance access to a device's GPU through web browsers. It aims to enable developers to create complex graphical applications and experiences on the web by utilizing modern GPU hardware for efficient graphics rendering. Due to their extensive usage and customized optimizations, current Federated Learning (FL) systems frequently concentrate on certain device types, such as smartphones or Internet of Things (IoT) devices. Nevertheless, FL's adaptability to other device kinds may be limited by this device-centric optimization, necessitating substantial coding and redesign work to modify FL systems for diverse device types. Because developers wind up building different and fragmented codebases for each device, this method violates software engineering principles of code reusability, making maintenance more difficult and impeding the effective deployment of FL. In this proposal, a novel WebGPU based federated learning network for heterogeneous device network is proposed. The proposal aims to deliver a working federated learning system supported by web browsers along with additional features.
Antrea's PacketCapture feature (https://github.com/antrea-io/antrea/blob/main/docs/packetcapture-guide.md) includes custom BPF code generation for packet filters defined in the PacketCapture CRD. The code is currently tested using manually-generated test cases, which is tedious, error-prone, and limits testing coverage. Given that the code attempts to mimic the BPF generation done by tcpdump, we should improve the testing approach by: 1) using AI to generate comprehensive test inputs, 2) using tcpdump to generate reference BPF code for the inputs, 3) comparing our generated BPF with the tcpdump reference, 4) analyzing any differences to determine if our BPF is incorrect or equivalent, 5) updating our BPF generation to match tcpdump when possible, and 6) committing all test cases to run in CI. Expected Outcome: A comprehensive test suite for the PacketCapture BPF generation code that uses tcpdump-generated BPF as a reference. The test suite should be integrated into CI and should increase testing coverage compared to the current manually-generated test cases. Any discrepancies between Antrea's BPF generation and tcpdump's should be analyzed and resolved, with the BPF generation code updated as needed to match tcpdump's output when appropriate.
Problem: R remains the gold standard in bioinformatics thanks to Bioconductor. However, many data scientists prefer Python for machine learning and building production. Currently, bridging tools such as rpy2 suffer a lot from stability issues. For instance, ABI symbolic linking errors and complex S4 object mapping failures, obstructing complete integration with essential tools like DESeq2. Solution: This project aims to enhance the Rosetta library by implementing a robust three-tier API architecture. This architecture includes an easy-to-use high-level Python interface, a fine-grained control layer for advanced users, and a subprocess-based fallback mechanism to prevent core crashes. I will focus on addressing deep interoperability challenges, including S4 method distribution and cross-language type conversion. Deliverables: 1.A stable, production-ready DESeq2 and edgeR Python wrapper library. 2.A three-tier API design ensuring 100% statistical consistency with native R output. 3.During periods of high load, the subroutine falls back to the backend to ensure system stability. 4.Comprehensive documentation and a Pytest-based validation suite ensure a reproducible experimental environment.
<p>Media source networks generated from Mediacloud topic graphs are currently visualized using software like Gephi with Force based layouts, however scaling the graph by expanding and contraction to reveal the network structure takes trial and error and domain expertise. Since python libraries like networkx don't have extensive support for network visualizations like Gephi, visualizing high dimensional networks become very hard. Multiple issues like node overlaps, label overlap , lack of utility functions, having a bad layout complicate the task of coming to a good network visualization.</p> <p>To solve it we implement <a href="https://github.com/Tahsin-Mayeesha/Mediaviz" target="_blank">Mediaviz</a>, a network visualization library which has been deployed as a package into pip. It provides functionalities for force based layout such as force atlas 2, automatic scaling to prevent node overlap, Gephi like features for network filtering, coloring, node resizing, prevention of label overlap and community visualization. Mediaviz uses force atlas 2 layout as default and scales the layout automatically for graphs with 100-1000 nodes that has a power law linking structure, but it can also be used with other layout algorithms.</p>
<p>DIRAC is an open source interware platform whose roles are submission of jobs, the management of the data produced, to the orchestration of the distributed resources. It is a generic software, used and extended by several Virtual Organizations (VO).</p> <p>It monitors resources like computing, storage, catalogue resources, networks, information providers, file transfer services, message queues or databases services. Members of a VO can use a mask composed of services exposed by local resources. Experienced Grid administrators apply procedures for managing such services, based on their status, as it is reported by an ever-growing set of monitoring tools. When a procedure is agreed and well-exercised, a formal policy could be derived.</p> <p>For this reason, using the DIRAC framework is developed as a policy system that can enforce management and operational policies, in a VO-specific fashion.</p> <p>This project proposal offers :</p> <ul> <li>A reliable working implementation of a multi-VO Dirac Resource Status System (RSS).</li> <li>A base database access module for the RSS which would unify the SQLAlchemy frontend and also reduce code duplication.</li> <li>Remove sqlite3 from some RSS modules and port them to MySQL backend</li> </ul>
<p>In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation.</p> <p>ROOT is a framework for data processing, born at CERN, at the heart of the research on high-energy physics. Every day, thousands of physicists use ROOT applications to analyze their data or to perform simulations. ROOT has a clang-based C++ interpreter Cling and integrates with Clad to enable flexible automatic differentiation facility.</p> <p><code>TFormula</code> is a ROOT class which bridges compiled and interpreted code.</p> <p>The project aims to add second order derivative support in <code>TFormula</code> using <code>clad::hessian</code>. The PR that added support for gradients in ROOT is taken as a reference and can be accessed <a href="https://github.com/root-project/root/pull/2745" target="_blank">here</a>.</p> <p>Optionally, if time permits, this project will also convert the gradient function into CUDA device kernels.</p>
<p>CuckooML will deliver a mechanism to find similarities between malware through analysing reports about them. Additionally, the software will be able to detect new types of malware - reports not similar to anything seen before (anomalies) - hence, it will constitute an invaluable tool for security researchers.</p> <p>Through the project a state of the art data science and machine learning approaches will be developed and integrated into Cuckoo package being accessible through both: command-line toolkit and as a web based interface.<br> First and foremost, a set of <em>features</em> that well represents the diversity of malware reports will be engineered; it is a common knowledge that the classification - clustering in particular - can only be as good as the features that are used.<br> The development will be focused on <strong>fuzzy</strong> (<em>soft</em>) clustering approaches that can be easily <em>calibrated</em> to maximise their performance. Additionally, the <em>probabilities</em> returned by the classifier will be adapted to serve as <strong>novelty detection</strong> mechanism.<br> Finally, developed approach will be <em>versatile</em> in a sense that user will be able to choose a <strong>context</strong> based on which clustering is performed e.g. platforms at risk, type of threat, etc.</p>
*OPEN TO US BASED STUDENTS ONLY* - Accepting applications until May 23, 2025 Primary Focus: This mentorship program focuses on optimizing VS tests and thereby reducing the flakiness and improving the checker time. Problem statement: VS tests plays a crucial role in PR checkers and ensuring zero regressions. However, the current infra-structure can take up to 4hrs to run the VS test and for any single failure, the rerun costs time and manual efforts. This project idea is to make VS test more robust and convert top flaky VS tests to mock test. Internship Objectives: - Convert VS tests from pytest to mock/mock test - Run current PR checkers and with unit tests and measure the time. - Aim to reduce the PR checker time significantly and predictable results Expected Outcomes and Deliverables: - Reduce the time for PR checkers and get consistent results - Submit a pull request and upstream the code changes to the SONiC swss repo. Recommended Qualifications: Education: - Undergrad student. Skills & Interests: - Eager to contribute to the SONiC open-source community. - Have Linux, Python/C/C++ experience - Academic background in Computer Science, Computer Engineering, or a related field.
This project aims to resolve the computational bottleneck in self-collision detection within the OCS2 framework for humanoid robotics. The current implementation in ocs2_self_collision operates on a pair-by-pair basis, iterating through collision pairs and calling PinocchioGeometryInterface::computeDistances() followed by Jacobian and penalty term calculations. This sequential approach is not SIMD-friendly by default and fails to utilize the parallel processing power of modern CPUs. To address this, I propose replacing the current computeDistances()-based distance computation with a high-performance implementation inspired by SIMD-amenable structures. A primary focus will be exploring / integrating SIMD-friendly data structures, such as Collision-Affording Point Trees (CAPT), to represent the storage and computation of collisions. This transition aims to transform the collision pipeline into a vectorized workflow that can be efficiently accelerated using AVX2 intrinsics. The primary deliverables include the clean integration of this accelerated engine into the ocs2_self_collision pipeline, accompanied by rigorous correctness checks against Pinocchio/FCL baselines. Furthermore, I will provide a comprehensive end-to-end latency evaluation using ocs2_mobile_manipulator to demonstrate the reduction in average and maximum compute cycle times. This work will significantly enhance the real-time performance of MPC-based humanoid control in complex environments.
<p>Educational institutions, open-source projects and private organizations have the need to create and maintain educational content such as classes, assignments, handbooks and onboarding material. This material is often stored as binary files and shared manually by email or extractable drives. This means that it often gets lost when people leave their organization, changes go unnoticed and error fixes take long to apply and share with the students. This makes collaboration very difficult for both the educators and the students.</p> <p>That's why <em>Courseware as Code</em> brings the good practices of <strong>DevOps</strong> and <strong>CI/CD</strong> into education. Using <code>git</code> for version control and <code>markdown</code> for formatted text, institutions will now be able collaborate and keep track of their educational content. Plus by using <em>Gitlab</em> <code>CI/CD pipelines</code>, new and novel ways of interacting with this content opens up.</p> <p>But building this workflow from the ground up is tough, especially for non-technical users. With a good template, clear documentation/tutorials and already implemented <strong>CI/CD</strong> pipelines, we plan to make it easy for any user to spin-up their own <em>Courseware as Code</em> implementation.</p>
Stochastic simulation is essential in computational biology and infectious disease modelling, but existing methods require a trade-off between accuracy and computational efficiency. While exact stochastic simulation captures dynamics in small populations, it scales poorly, whereas deterministic ODE models are efficient but fail to capture stochastic effects. The Jump-Switch-Flow (JSF) framework addresses this by dynamically switching between stochastic simulation and deterministic ODE integration based on population size. However, despite a mature Python implementation, R remains the dominant language in epidemiology and biostatistics, creating a significant accessibility gap. This project will develop rjsf, an R package that provides user-friendly functions for running the Python `jsf` library directly within R workflows via reticulate. Key deliverables include a core simulation function, S7-based result objects, diagnostic and visualisation tools, a comprehensive test suite, and a detailed vignette, with the goal of CRAN submission. As a stretch goal, the project will explore incorporating additional intermediate stochastic simulation methods to further enhance flexibility and performance. The resulting package will enable researchers and scientists to seamlessly integrate hybrid stochastic-deterministic simulation into their existing R-based modelling workflows.
The proposal outlines a comprehensive plan to enhance the model's accuracy and efficiency, coupled with new user interface (UI) integrations. First, the optimization of machine learning and statistical models will focus on Exploratory Data Analysis (EDA), feature reduction, feature engineering, and employing better imputation techniques for handling missing data. This will streamline the process and improve model performance. Additionally, fine-tuning a rule-based system will involve adjusting and normalizing feature weights, alongside providing users with tailored recommendations based on our analysis. Another key objective is the integration of new datasets. Currently, each dataset requires different handling, and by incorporating a new dataset, we aim to deliver more refined insights. To address data imbalance, techniques such as minority class upsampling and additional data generation methods will be applied. This ensures the model can better handle unbalanced data distributions. Fraud detection is also a critical focus, with plans to identify suitable datasets and initiate the development of robust fraud detection capabilities. Lastly, improvements in federated learning will be made to ensure data privacy and efficiency, allowing the model to learn from decentralized data without compromising individual data security.