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.
In this project, we aim to demonstrate an open-source example deployment of a fully functional workload. This project focuses on the entertainment vertical, the main idea is to segment movies into scenes and make the segmented scenes queryable with natural language text. This project would involve LLMs, text embeddings to create scene summaries and vector database to store the embeddings for each scene, so that it can be queried easily . We will brainstorm an end-to-end example approach and explore the possibility of adapting certain components to different technological contexts. Our strategy involves utilizing Rancher, a Kubernetes-as-a-Service platform, to efficiently manage clusters and deploy microservices.
Adding support of a new file format (SPDX 3.0) and a new compliance standard (EU Artificial Intelligence Act) for SPDX SBOM Conformance Checker. This proposal introduces two key capabilities: 1) SPDX 3.0 Parsing: Add ability to parse SBOMs in SPDX 3.0 JSON format and build a computational model of the SBOM for further processing. 2) EU AI Act Compliance Checks: Add ability to assess SBOM conformance against selected provisions of the EU AI Act. For example, concerning Article 49 (Registration), the checker will analyze the SBOM to determine if it includes the information mandated by Annex VIII, providing users with a clear report on present and missing data elements.
Proposal Summary: Interaction to Next Paint (INP) Subparts Problem Statement: The recently introduced Interaction to Next Paint (INP) metric, integrated into the Core Web Vitals (CWV) system in 2024, aims at measuring user interaction performance. However, INP lacks granularity, making it difficult for developers to diagnose and address specific latency issues within different stages of event processing and rendering. Solution Approach: To enhance the diagnostic capabilities of INP, this proposal suggests breaking down the INP metric into its sub-dimensions—input delay, processing time, and presentation delay—by leveraging modifications to Chromium’s Event Timing API. These fine-grained timestamps will be transmitted from the Renderer process to the Browser process via Mojo IPC, eventually integrating these metrics into the UKM metric system and CrUX experimental dataset. The project will involve updating the PageLoadMetricsSender to include detailed timing data for each event, as well as enhancing the UkmPageLoadMetricsObserver to handle both old and new data formats seamlessly. Deliverables: 1. Prototype Verification: Establish a proof-of-concept for collecting sub-dimension data using Chromium’s debugging environment. 2. Mojo Protocol Modification: Extend existing IPC interfaces to support new subpart timings. 3. UKM Integration: Implement new UKM metrics reporting and update relevant configurations. 4. Test Suite Development: Develop comprehensive tests including Web Platform Tests/WPT cases and unit test coverage. 5. Performance Regression Testing: Analyze benchmark reports and memory usage to ensure no negative impact on performance. 6. Documentation & Wrap-up: Provide detailed design documentation and outline plans for integrating improvements into CrUX.
This project aims to introduce a structured, automated deprecation system for the Ganga project. Ganga currently lacks a formal process for phasing out legacy APIs and outdated code, resulting in accumulated technical debt and maintenance difficulties. The proposed solution includes decorator-based deprecation utilities (leveraging PEP 702), CI workflows to track expiry deadlines, and tools to detect regressions using deprecated features in pull requests. Deliverables also include test coverage and tooling for maintainers to enforce clean removals. This will improve maintainability, reduce clutter, and enhance developer experience across the project.
Project Summary: Real-Time Traffic Prediction and Management System Problem: Urban traffic congestion poses significant challenges, leading to delays, increased pollution, and inefficient resource allocation. Existing systems often lack real-time predictive capabilities and edge-based solutions, limiting their effectiveness in dynamic environments. Solution: This project will develop a scalable, real-time traffic prediction and management system using AI-driven models (e.g., LSTM, GRU) trained on diverse data sources (Kaggle, OpenStreetMap, real-time APIs). The solution will integrate a data ingestion pipeline (using Apache Kafka/Airflow,ML), deploy models on edge devices via Docker and Kubernetes, and provide a Streamlit-based web UI for visualization and alerts. The system will predict traffic flow, detect anomalies, and trigger congestion alerts to optimize traffic management. Deliverables: A fully deployed edge-based traffic prediction microservice with low-latency inference. An automated data pipeline integrating multiple traffic data sources. A user-friendly Streamlit web interface for real-time monitoring and alerts. Comprehensive documentation (setup, architecture, deployment) and a 5-minute demo video showcasing the system’s capabilities.
Enable popular Keras Hub GenAI/LLM pipelines for the OpenVINO backend in Keras 3 and optimize their performance. This project focuses on implementing missing operations in the OpenVINO backend to support and accelerate Gemma, Mistral, and GPT-2 pipelines for efficient inference. Additionally, it adds support for exporting these models to OpenVINO IR format using any backend. The final deliverables include 3 fully enabled and optimized pipelines running on Keras 3 with OpenVINO, along with reliable export functionality.
This project delivers a Dockerized RStudio/Shiny application for analyzing biomedical datasets stored as Apache Avro files conforming to the Portable Format for Biomedical Data (PFB) standard. Leveraging Apache Spark via the sparklyr interface, the system efficiently ingests and processes large, deeply nested Avro inputs (40,000+ records) and flattens hierarchical entity structures into analysis-ready tabular data. Users can explore entity and observation nodes, generate descriptive summaries and percentage distributions, and run survival analyses Kaplan–Meier overall survival (OS) and event-free survival (EFS) both on subject IDs uploaded by the user and on the full dataset. A configurable Table-1 workflow supports covariate selection; explicit variable typing (categorical or continuous); inclusion/exclusion of variables and, for categorical variables, specific levels; and p-value computation when grouping is applied. Grouping is enabled by uploading subject-ID lists (CSV, Excel, or plain text), which automatically creates a matched group and a complementary remainder group; if no list is provided, analyses default to the entire cohort. The application supports iterative regrouping, clearing of results, and re-analysis with new inputs. Outputs include Excel summaries and PNG visualizations for direct download. Containerization ensures reproducibility, consistency, and portability across environments, while Spark integration provides distributed, scalable processing. The solution can also be deployed on AWS (e.g., EC2 or ECS) to provide secure, scalable remote access for research teams.
This project aims to develop and benchmark high-performance applications that leverage the modular SoC-Now platform, which integrates RISC-V cores, a vector coprocessor (Vaquita), and a post-quantum cryptography accelerator (Baby Kyber). The project will focus on building real-world applications such as image processing, machine learning inference, and secure communication, utilizing Vaquita for vectorized computing and Baby Kyber for post-quantum encryption. These applications will be designed, implemented, and tested on the SoC-Now platform, demonstrating the practical benefits of these hardware accelerators. The goal is to provide the open-source community with reusable application code and detailed performance benchmarks, showcasing the capabilities of SoC-Now in secure computing and efficient AI acceleration. The project will include the development of hybrid applications combining cryptography and vector processing, along with complete documentation and tutorials to make it easy for future developers to leverage the platform for their own projects. Deliverables will include working applications, performance benchmarks, and reusable code packaged for community use, with future work aiming to expand the scope with additional cryptographic primitives, AI models, and improved software stack integration.
This project will result in functionality for both TARDIS and STARDIS to identify and display a user provided list of atomic and molecular lines to existing spectral visualizations. This will be done by leveraging information stored in the simulation's energy packets to identify source species. This is critical work as observed spectra often have blended line features due to the high ejecta speeds broadening neighboring lines into each other; However, in the simulated spectra, source packets are known and thus blended lines can be disentangled. This work will enable simple comparisons with published, labeled spectra; identification of unlabeled features in newly observed spectra; a physical understanding of new models; and development of publication-ready plots.
The aim of this project is to bring State of the Art methods for lightweight Visual Language models into Kornia in Rust. Recently, Hugging Face released a family of small visual language models (SmolVLM) which can be a game changer for the industry to build applications in embedded devices using such AI models.
The project aims to enhance the cBioPortal platform by generating a list of recommended default genes for each OncoTree code, which are often used for molecular classification of specific cancer subtypes. This will improve the effectiveness of the cBioPortal database by prioritizing the display of relevant genes to each disease subtype. To achieve this goal, a Large Language Model (LLM) such as GPT-4o, will be fine-tuned with prompt engineering and Retrieval-Augmented Generation (RAG) techniques to provide domain-specific knowledge and context. The goal is to train the LLM to connect relevant genes to each OncoTree code. Approach: LLM Selection: GPT-4o is a strong candidate due to its versatility and performance in various NLP tasks. Prompt Engineering: Develop efficient prompts for the selected LLM to generate gene lists. RAG Component: Implement a RAG component to provide context to the LLM and enhance accuracy using e-utilities to retrieve curated literature from NCBI GeneReviews and ClinVar. Validation: Cross-reference the generated gene lists with expert-curated resources like ClinGen and variant frequencies in cBioPortal, and COSMIC. Evaluation: Continuously monitor the model's performance using validation sets and adjust hyperparameters as needed. Deployment: Integrate the solution into the cBioPortal platform such as sorting variants on patient view pages by relevant genes first. Conclusion: Completion of this project will significantly improve the usability of cBioPortal, providing users like researchers and clinicians with relevant gene and pathway information based on the cancer type they are exploring.
This project aims to implement visual regression testing pipeline for Rocket.Chat’s component library, Fuselage, using Loki. The current workflow lacks automated visual checks, making it difficult to detect unintended UI changes. By integrating Loki—a lightweight and self-hosted visual regression tool—with Storybook and GitHub Actions, The result will be a scalable, cost-effective, and developer-friendly solution that increases UI reliability and reduces manual review effort. Deliverables: Loki integration with Storybook for Fuselage Stable snapshot testing environment with consistent rendering CI workflow integration to detect and report visual diffs Visual regression coverage for Rocket.Chat screens
Cantor is a core tool in the KDE ecosystem that focuses on scientific computing and interactive analysis. It supports mathematical modeling and data visualization through engines such as Python, Julia, and Maxima. In order to improve its text editing experience and maintainability, this project plans to deeply integrate the KTextEditor framework to transform Cantor into a more "developer-friendly" scientific research platform. By using QGraphicsProxyWidget to seamlessly replace existing custom cells, professional functions such as Vi editing mode, intelligent code completion, dynamic syntax highlighting (supporting user-defined symbol injection) are implemented, while simplifying the code structure and reducing redundant component code. This improvement not only aligns Cantor's editing experience with KDE professional tools such as Kate and KDevelop, but also lays the foundation for future integrated debuggers, version control and other advanced functions by sharing the KTextEditor plug-in ecosystem.
The 3D PDF Export for FreeCAD project aims to develop a native capability for exporting interactive 3D models directly to PDF format, enhancing FreeCAD's documentation and collaboration capabilities. Currently, FreeCAD users must rely on complex multi-step workflows involving external tools like MeshLab, LaTeX, or even commercial CAD software to create 3D PDFs, often resulting in loss of model fidelity, colors, and structure. This project proposes implementing a seamless 3D PDF export feature integrated directly into FreeCAD's TechDraw workbench. Users will be able to create standard technical drawings with traditional orthographic views and dimensions, plus an interactive 3D view that appears as a regular isometric view in print but becomes fully interactive when viewed digitally. Key components of the implementation include: 1. Document Structure Access: Utilizing FreeCAD's Python API to traverse the document object hierarchy or need to rely on Qt for accessing certain structural information. 2. 3D Format Conversion: Implementing exporters for both U3D format and PRC format to support NURBS surfaces for higher fidelity representation. 3. PDF Generation: Creating a PDF container that properly embeds the 3D content with interactive viewing capabilities. 4. TechDraw Integration: Extending the TechDraw workbench to include a new "3D View" type alongside traditional orthographic views. The completed feature will significantly enhance FreeCAD's usability for professional documentation, enabling users to share interactive 3D models with clients and collaborators who don't have CAD software, addressing a long-requested feature within the FreeCAD community.
This is a proposal to extend Datashuttle's functionality to allow connections to Google Drive and AWS buckets as remote storage options. This project aims to improves the flexibility and adoption of Datashuttle to allow neuroscience researchers use a variety of storage options with the most popular ones being Google Drive and AWS buckets. This will be done by extending Rclone's wrapping of Datashuttle and extending the terminal user interface to allow connections to Google Drive and AWS buckets. **Deliverables** - Support for setting up connections to Google Drive and AWS and transferring data in the Datashuttle's Python API using Rclone. - TUI tabs and screens to enable users to setup connections to Google Drive and AWS and transfer data via the TUI. - Integration and TUI tests for the implemented features. - Documentation for setting up Google Drive or AWS as central storage.
This project aims to optimize the open-source AV1 decoder, dav1d, for the RISC-V Vector (RVV) ISA by implementing Vector-Length Agnostic (VLA) intrinsics. The focus is on improving AV1 decoding performance across various resolutions and bit depths through dynamic vector-length handling, with benchmarking on real hardware like the Kendryte K230 (VLEN = 128 bits), the SpacemiT K1 (VLEN = 256 bit) and comparisons against ARM NEON using built-in dav1d tooling such as checkasm for detailed analysis.
Intel™’s Advanced Configuration and Power Interface (ACPI) is an industry standard specification that revolutionized power management by putting it in the hands of the operating system, rather than the BIOS. As it currently stands, it is widely available across 32-bit and 64-bit architectures, with specially tailored manuals towards Windows™ and UNIX. FreeBSD has implemented ACPI, utilizing Intel™’s ACPI Computer Architecture (ACPICA). The major contention point is that it is outside the loader. In this state, it is inefficient; information that’s only available to ACPI, is therefore unavailable to the boot loader. As such, the boot loader essentially has to guess what that information is, and is often wrong. This proposal aims to alleviate this bottleneck by bringing a lightweight version of ACPICA into the loader. With this integration, ACPI will not only be more efficiently managed, but it will also be script-able with Lua, providing FreeBSD users ease of configuration. Deliverables include: (1) stand/efi/acpica/Osd/ with necessary ACPICA/AML initialization, (2) stand/efi/loader/arch/$ARCH for arm64 and amd64 specific glue code, (3) complete integration of both architectures: ACPI initialized in the loader, (4) the ACPI namespace enumerated in C, (5) an ACPI API layer, (6) Lua bindings, and (7) updated FreeBSD ACPI handbook and man pages.
VB-LoRA (Vector Bank Low-Rank Adaptation) is a parameter-efficient fine-tuning technique that extends LoRA (Low-Rank Adaptation) by introducing a shared vector bank and a differentiable top-k selection mechanism. This allows dense layers to adapt to new tasks by training a small set of parameters while keeping the original weights frozen. The goal of this project is to implement VB-LoRA in Keras, integrating it into layers—Dense, EinsumDense, BaseConv, Embedding, and Attention —and extending it to the backbones of model architectures in Keras Hub. The implementation will involve initializing VB-LoRA parameters, creating a vector bank and logits, computing low-rank matrices, and ensuring seamless integration with comprehensive testing and documentation.
Recolor Artwork in Inkscape : Inkscape currently lacks an easy and intuitive way to modify colors within a selected artwork. This project aims to introduce a "Recolor Artwork" tool that allows users to quickly adjust colors in their selection, making color experimentation and fine-tuning more efficient. The feature will extract all colors (fills, strokes, and gradient stops) from the selected objects and present them in a list. Users will be able to edit colors by either clicking on a color in the list or using a color wheel, which will help visualize relationships between colors. The tool will feature live preview, allowing real-time updates on the canvas, and upon deselection, the new colors will be applied permanently. If performance concerns arise, an apply/load button or a pop-up dialog similar to the LPE editor will be considered. Deliverables: A dialog or pop-up UI that lists all colors from the selection. Color editing options, including direct tweaking and a color wheel. Live preview of color changes on the canvas. Performance optimizations, including a possible load/apply mechanism if needed. This feature will improve the workflow of designers using Inkscape, making color adjustments more accessible and efficient.
This Google Summer of Code (GSoC) project aims to enhance the Open Food Facts Explorer by implementing new features, ensuring design consistency, improving backend API support, and elevating the overall user experience. The Explorer acts as a user-friendly portal where contributors can explore food data, contribute new information, and visualize relationships among food products. Throughout the summer, I will work on bringing feature parity with the main website by adding login flow, advanced search capability, image editing features, and more. Additionally, I will extend functionalities through the Open Prices integration, contribute to reusable web components, and enhance automation using GitHub Actions and Storybook. The project is divided into focused milestones to ensure consistent progress, including buffer periods for testing and documentation.
This proposal focuses on developing the Raindrop Protocol, a staking and dividend distribution mechanism designed to ensure transparent and fair revenue sharing among contributors by leveraging secure token vaults. Additionally, it involves enhancing the existing Plaza frontend by improving user experience, optimizing smart contract interactions, and integrating multi-wallet connectivity, resulting in a seamless and intuitive interface for community-driven blockchain projects.
The OWASP Nest API and Schema Development project aims to enhance OWASP Nest API infrastructure by migrating to Django Ninja for optimized REST API performance, replacing Graphene with Strawberry GraphQL, and implementing structured API key management for secure authentication. Additionally, it introduces YAML-based JSON schemas to standardize metadata for OWASP projects, chapters, and committees, ensuring consistency across repositories. The project focuses on performance improvements through Redis caching and rate limiting, automated schema validation using GitHub Actions, and SDK generation in Python, Go, and TypeScript for easier integrations. Comprehensive API documentation will be developed using OpenAPI and Swagger UI, and 80%+ test coverage with Pytest will ensure stability. By implementing these enhancements, the project will improve security, maintainability, and developer experience, fostering a structured and efficient approach to OWASP Nest API and metadata management.
This project aims to implement Linux-compatible journaling within FreeBSD's ext filesystem, which is a standard feature in Linux's ext3 and ext4 filesystems. The absence of journaling in FreeBSD's implementation results in reduced filesystem consistency and slower recovery times after system crashes compared to its Linux. The proposed solution involves modifying the ext filesystem to understand the on-disk format and transaction mechanisms of Linux's journaling implementation. Key deliverables include integrated code for detecting, parsing, and managing journal data, functional logging of metadata changes within transactions, a complete implementation for committing these transactions to the on-disk journal, integration of journaling across major metadata operations, support for ordered journaling mode, and comprehensive test cases accompanied by thorough documentation.
The integration of automatic differentiation (autodiff) into the Rust compiler via Enzyme faces challenges due to ABI adjustments that alter function signatures. These transformations, while beneficial for performance, interfere with autodiff functionality, leading to incorrect differentiation. This project aims to prevent unwanted ABI adjustments for functions marked with #[rustc_autodiff], ensuring autodiff functions maintain their intended behavior without affecting other optimizations. The approach involves modifying Rust’s function ABI handling to recognize and preserve differentiation-related information. Key steps include identifying problematic transformations, encoding autodiff metadata in FnAbi, and preventing ABI changes that break autodiff. By addressing these challenges, the project will improve autodiff support in Rust, making it more reliable and consistent while preserving compiler efficiency.