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.
Jaeger’s Service Performance Management (SPM) currently requires a complex setup with a separate processor and Prometheus storage to compute RED metrics. This project simplifies SPM by using Elasticsearch/OpenSearch trace storage to directly derive metrics, eliminating extra components. I will implement an ElasticsearchMetricsReader, update configurations, ensure OpenSearch compatibility, and add tests and documentation. Deliverables include a new development environment, simplified configuration, integration tests, OpenSearch support, updated documentation, and load testing for scalability.
The KomMonitor web client, a tool for geospatial data monitoring in urban planning, is currently based on AngularJS and requires a complete migration to the modern Angular framework to improve maintainability, scalability, and ease future contributions. While migration started previously, significant parts remain in AngularJS, and foundational issues like specific AngularJS patterns ($rootScope, $compile) and JavaScript files hinder the direct use of standard upgrade tools. Solution: This project aims to fully migrate the KomMonitor web client from AngularJS to Angular. The approach involves: 1. Addressing the foundational roadblocks identified by analysis tools (e.g., refactoring $rootScope usage, eliminating $compile, converting JavaScript to TypeScript). 2. Incrementally migrating remaining AngularJS components and services to Angular, leveraging ngUpgrade within a hybrid architecture during the transition. 3. Implementing modern Angular best practices, including modular architecture, dependency injection, and potentially lazy loading. 4. Refactoring components using design patterns like Observer (RxJS), Facade, and Container-Presenter to improve structure and data handling. 5. Ensuring UI consistency using ng-bootstrap. 6. Establishing a robust testing strategy encompassing unit, integration, and end-to-end tests using frameworks like Jest and Cypress. Deliverables: 1. A fully migrated KomMonitor web client codebase, transitioned from AngularJS to Angular. 2. Resolution of key AngularJS patterns ($rootScope, $compile) and conversion of necessary JavaScript files to TypeScript. 3. Migrated and optimized components/services adhering to modern Angular standards and design patterns. 4. A comprehensive test suite ensuring application stability and functionality post-migration. 5. Updated documentation reflecting the migrated codebase. 6. Final project code, documentation, and evaluation report.
This project aims to enhance the accuracy and reliability of geometric intersection routines in Inkscape’s lib2geom library by refactoring them with interval arithmetic. Traditional floating-point methods often introduce numerical errors, which can result in incorrect or unstable path operations. Interval arithmetic enables us to compute guaranteed bounds for intersections, handle edge cases more robustly, and ensure greater numerical stability. These improved routines will also serve as a foundation for constructing a guaranteed planar graph, supporting advanced features such as boolean operations and path offsetting.
The Talawa Mobile App Refactor and Enhancement project addresses technical debt, usability issues, and security concerns to deliver an optimized user experience. Key improvements include a robust security framework, real-time notifications, enhanced event management features, semiotic UX upgrades like animations and visual cues, and code optimization for modularity and efficiency. These updates aim to create a seamless, secure, and user-friendly app.
ProRes is a popular codec for video editors and professional due to its high quality. FFmpeg has supported it for a while, but lacks hardware acceleration outside of MacOS. Using vulkan compute shaders, encoding performance can be increased in a cross platform way, using modern GPUs
The project involves adding support for the I2C, PWM, DMA and Mailbox functionalities. The ARM based Raspberry Pi 3 BSP has support for I2C although it is not the same for the AARCH64 based Raspberry Pi 4b BSP. PWM Support is something that would make the BSP more useful, and in the proposal I have mentioned how I will go about adding the support. DMA and Mailbox are two of the functionalities that are required to add SD Card support to the BSP. In the proposal I have given an overview of how I plan to add support for DMA and Mailbox.
This project focused on transforming FOSSASIA’s static web infrastructure into a dynamic, scalable, and contributor-friendly WordPress ecosystem. The goal was to migrate Codeheat.org from GitHub Pages to WordPress, introduce reusable templates for generating yearly contest sites, and improve FOSSASIA’s overall web workflows. Alongside the website migration, I integrated widely used open-source plugins—such as Contact Form 7 and Noptin—to enhance community interaction, mailing list management, and content organization. A key part of the project involved extending and improving the wpfa-mailconnect plugin by adding SMTP configuration, email logging, and a more reliable internal architecture. These changes make communication systems easier to maintain and expand across multiple FOSSASIA websites. Throughout the project, the focus remained on creating maintainable solutions with minimal custom code, ensuring long-term scalability and ease of adoption for contributors. The result is a modernized, more flexible web foundation that supports improved performance, better content management, and future integration with additional FOSSASIA tools.
The Mission Support System (MSS) client currently lacks the ability to save and restore view configurations, requiring users to manually recreate complex window layouts each time they reopen the application. Additionally, collaborative operations do not support sharing view configurations among participants, hindering real-time coordination. To enhance the user experience and collaboration in the Mission Support System (MSS), this project will introduce two major improvements. First, it will implement a local and server-side view restoration system, allowing users to save and reload their window layouts automatically. This will be achieved through JSON-based storage for local configurations and database integration for server-side persistence. Users will have the option to enable or disable view restoration via a new setting, ensuring flexibility. Second, the project will introduce a collaborative view-sharing feature through a dedicated "Manage View" widget. This will enable participants in an operation to share, browse, and load predefined layouts, ensuring consistency during joint missions. The widget will integrate with MSS’s existing operation system, allowing real-time updates via WebSocket notifications. Backend APIs will handle secure storage and retrieval of shared views, while the frontend will provide an intuitive interface for managing layouts. Together, these enhancements will eliminate the need for manual reconfiguration and streamline teamwork in mission planning and analysis.
This project aims to develop a Python library to support Xarray data (labeled multi-dimensional array library supported by Deepmind) with JAX (Google's differentiable programming framework). This will address the lack of support for labeled multi-dimensional data in machine learning frameworks, extending scientific computing capabilities for domains like weather forecasting and financial modeling. Building on Google Deepmind's Xarray-JAX implementation in Graphcast, I will create a standalone library that leverages JAX's recent Python Array API standard implementation to replace the current wrapper-based approach with native integration. The solution will include direct JAX array usage through the API, updated coordinate handling, adapted tree utility registrations, and preservation of existing functionality. Deliverables include a production-ready xarray-jax library on PyPI, comprehensive test suite, tutorial notebook demonstrating usage, and documentation covering core functionality. This integration will enable scientists and researchers to work with labeled multi-dimensional data in JAX.
Currently, the new, experimental GCC based compiler backend for Rust(`rustc_codegeng_gcc`) is not able to build the Rust compiler. The goal of this proposal is to add the fixes and features necessary for `cg_gcc` to build a fully functional stage 2(and possibly 3) of the Rust compiler. This will require adding support for 128 bit SwitchInt terminators, fixing recursive `#[inline(always)]`, and plugging some soundness holes within the backend. This should help the GCC based codegen become more mature. In the future, this could also open the way towards building and running the Rust compiler on platforms not supported by LLVM. Improving this codegen backend could allow Rust to be used in more places, speeding up the language's adoption.
As PSLab transitions from a native Android app to a Flutter-based cross-platform application, this project focuses on developing and enhancing core sensor modules, building a reusable experimentation framework, and introducing advanced features for data handling and visualization. The aim is to deliver a cohesive, extensible system that not only replicates existing functionality but significantly improves usability, scientific learning, and mobile data workflows. Alongside sensor integration, the project will introduce a reusable experimentation framework. To support effective data workflows, the project will include functionality for logging, exporting, and importing sensor data using CSV files. Additional focus will be placed on theming, localization, and in-app documentation to improve overall user experience and accessibility.
This project aims to replace Brian’s current just-in-time (JIT) compilation system, which relies on Cython. While functional, Cython introduces slow compile times and adds complexity by requiring separate code generation paths for Python and C++. The goal is to simplify and speed up Brian's runtime by: - Replacing Python-based structures (e.g. dynamic arrays, spike queues) with C++ equivalents - Enabling direct, efficient C++ calls from Python with shared memory - Exploring JIT alternatives like Numba or SciPy Weave - Refactoring the runtime to support this new architecture
Currently in Safaa Project data was manually curated And we see that most of the things are manual here. This project will concentrate on creating a pipeline, Scripts to copy copyright data automatically from fossology instance to train the model, Utilizing LLMS and deep learning techniques to increase the accuracy of our output.
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.