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.
Problem: KubeStellar (KS) lacks an automated system to measure and visualize data-plane performance (e.g., sync latencies) under AI workloads, making optimization and debugging challenging. Solution: 1. Instrument KS with OpenTelemetry/Prometheus to emit sync latency/error metrics. 2. Build a pipeline (TimescaleDB + Fluentd) to collect, store, and aggregate metrics. 3. Embed Grafana dashboards into KS UI for real-time monitoring. 4. Benchmark AI workloads (e.g., distributed TensorFlow) to validate scalability. Deliverables: 1. Go-based metric instrumentation in KS core. 2. Automated aggregation service (P95, error rates). 3. Prebuilt Grafana dashboards (latency, throughput). 4. Documentation + video demo. Impact: Enables data-driven optimization of KS for large-scale AI workloads.
My project aims to develop an immersive Augmented Reality (AR) Marine Ecosystem Simulation that will serve as an interactive educational tool within Catrobat's ecosystem. This simulation will allow users to explore marine environments through AR technology, visualizing complex ecological interactions such as food chains, coral reef dynamics, and the impacts of pollution in real-time. The primary challenge lies in creating a physically accurate, engaging simulation that runs efficiently on mobile devices while maintaining educational value. I propose to solve this by: - Developing a modular AR framework using Unity that integrates with ARKit and ARCore - Implementing realistic physics-based interactions between marine organisms - Creating an adaptive AI system that evolves the ecosystem based on user interactions - Designing intuitive interfaces that make complex ecological concepts accessible The project will deliver: - A fully functional AR marine ecosystem simulation compatible with Catrobat's existing applications - A library of interactive marine organisms with realistic behaviors and interactions - Real-time visualization tools for environmental factors (temperature, pH, pollution) - Educational scenarios demonstrating ecological principles - Comprehensive documentation and integration guides
Building a cli tool for kro resource management. using golang's cobra library. mentioned are the proposed tasks which are about to be completed under the project scope. Project goals: 1) Build a CLI tool to help developers and admins manage kro. 2) Create commands for common RGD operations [validate/generate/install/publish/package]. 3) Create commands to for RGD and instance viewing and dry-runs. 4) Create commands for monitoring and troubleshooting RGDs, instances and CRDs.
This project seeks to introduce the functionality of creating keyframes directly in the VSE preview by using the “I” or “K” key, adhering to the same rules and preferences as the 3D viewport, including keysets. This feature will allow users to keyframe sequences directly in the preview area, thereby improving the video editing workflow and facilitating quicker story-boarding.
This proposal for Taskserver II aims to enhance the existing CCSync Taskserver, developed during last year’s Google Summer of Code. The primary focus this year is to simplify setup and deployment by transitioning from limited or paid Firestore services to a free alternative such as RxDB. Additionally, Docker images for both the backend and frontend will be provided for easy self-hosting and deployment, making the Taskserver production-ready for the Taskwarrior Flutter App. Other key objectives include implementing Github Actions for the backend and frontend to automate testing on every new commit. Lastly, update CCSync’s documentation, including patch notes and a comprehensive installation guide.
A key component of Bayesian inference is integrating over prior distributions to obtain posteriors. In practice however, these distributions are often high-dimensional, resulting in a significant computational cost associated with integration, which remains a key challenge in Bayesian ML. Under certain assumptions, it is possible to efficiently compute posteriors for Latent Gaussian Models (LGMs), which represent a broad class of statistical models in Bayesian statistics. This is known as the method of Integrated Nested Laplace Approximations (INLA), and this project aims to implement a working basis for INLA in the PyMC library.
Security teams and open-source organizations often struggle with managing vulnerability reports, bug bounties, and contributor performance efficiently. The current organization dashboard lacks advanced filtering, real-time analytics, and collaboration tools, making it difficult to track and resolve security issues effectively. This project aims to redesign and enhance the dashboard to provide a more intuitive, data-driven, and collaborative experience. Using Django Templates/HTMX and Tailwind CSS, the new dashboard will introduce advanced filtering, interactive analytics, and role-based collaboration tools to streamline vulnerability management. Key Deliverables: 1. Redesigned Dashboard UI for seamless navigation. 2. Advanced Filtering & Search for security reports. 3. Real-time Analytics & Insights for better decision-making. 4. Collaboration Features (issue assignment, commenting, notifications). 5. Optimized Backend with secure API endpoints and role-based access. 6. Comprehensive Testing & Documentation for future maintainability.
This project aims to address the challenge of creating a seamless and efficient integration between Gemini and Vertex AI in Firebase for Android and iOS platforms using Kotlin Multiplatform (KMP). The proposed solution is to develop an open-source KMP library that will support Gemini with Vertex AI in Firebase, focusing on best practices for creating KMP libraries and ensuring robust production implementation across both Android and iOS platforms. The deliverables for this project will include: 1. Kotlin Multiplatform Library: This library will provide seamless integration between Gemini and Vertex AI in Firebase, supporting Android and iOS. 2. Sample Code and Documentation: Along with the library, sample code and thorough documentation will be provided to assist developers in utilizing the library effectively for their own projects. In practice, developers can integrate this library into their Kotlin Multiplatform applications. Our library will offer a seamless process of integrating Vertex AI into Firebase apps for both iOS and Android.
I aim to improve the Welcome page and create a walkthrough in JabRef. The walkthrough would: 1. Provide an overview of JabRef's core functionality 2. Ask users to select their user type 3. Configure software with sensible default settings based on user type 4. Demonstrate relevant features using a sample library The walkthrough would be personalized based on the user's selected type, helping new users understand the features most relevant to their needs. Additional walkthroughs may be implemented depending on if there is additional time.
Development and integration of the functionality for simultaneous control of two robots, aimed at applying dual-site Transcranial Magnetic Stimulation (TMS) in InVesalius (currently, support is provided for only one TMS coil attached to one robot). This feature is based on the existing implementation for the use of two or more coils, adapting it for multiple robots. The inclusion of this feature not only improves the speed, accuracy, and safety of the stimulatory process, but also enables the scientific exploration of interactive brain networks, by allowing concurrent, targeted TMS pulses to multiple brain areas.
This project aims to implement a Vector Tracking Loop (VTL) architecture in GNSS-SDR, a widely used open-source software-defined GNSS receiver. Traditional scalar tracking architecture tracks satellite signals independently, limiting robustness in dynamic or degraded signal environments. In contrast, VTL integrates tracking and navigation tasks into a single algorithm, where all channels collaborate to enhance signal tracking performance, particularly under challenging conditions such as interference or temporary outages. The proposed work will design and integrate a modular, configurable VTL architecture supporting multi-constellation and multi-frequency operation, aligning with the existing capabilities of GNSS-SDR. Deliverables include: VTL algorithm implementation, real-time feedback to tracking channels, multi-constellation and multi-frequency support, benchmarking, and documentation. This contribution will enable researchers and developers to explore advanced GNSS techniques related to the VTL architecture within a real-time, open-source SDR.
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.