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: Traditional ArUco markers in OpenCV struggle with occlusion and long-range detection. Fractal ArUco markers (developed by Prof. Rafael Muñoz Salinas and team) address these limitations through nested designs but are not yet integrated into OpenCV. Solution: 1. Replace the current picoflann dependency with OpenCV’s native FLANN module (kdtree_single_index). 2. Benchmark both implementations for accuracy, speed, and memory efficiency. 3. Integrate the optimal solution into OpenCV, ensuring backward compatibility and performance. Deliverables: 1. Fractal ArUco integration in OpenCV 2. Documentation (API references, tutorials, performance guidelines) 3. Merged OpenCV pull request with tests and examples
optimagic is a optimization library which aims to provide a unified interface to optimizers from SciPy, NlOpt and many other widely used packages. This project aims to add more optimizers specifically from ensmallen, PRIMA, Nevergrad, Bayesian Optimization, Knitro and if possible, others. I will implement each particular optimizer, reading the literature and official documentation related to each optimizer, and keeping in mind optimagic's core idea. The main goal is to wrap as many optimizers as possible, giving them a consistent interface with optimagic's minimize function. For users, this will mean more freedom while choosing and comparing optimizers that best suits their needs. This will involve writing well-tested code, tests, and benchmarking to further improve performance. Also, I will write documentation, how-to-guides and example notebooks to guide users using the library.
The goal of this project is to parallelize the CGAL Tetrahedral Remeshing package using the Intel Threading Building Blocks (TBB) library. This will significantly reduce the computational time required for remeshing large meshes, enabling faster and more efficient simulations. CGAL already provides some parallel implementations for some of its packages. While the primary focus is to parallelize the Remeshing package, a key objective is to lay the foundation for a generic parallelization framework for CGAL. Analogously to C++ STL's execution policies we would like to develop a framework that could, as future work, be extended to the rest of the library and allow to seamlessly change execution policies. The core of this proposal is a generic framework for the parallel execution of atomic operations using TBB in the remeshing package.
The torch ecosystem is rapidly growing in R, but it still lacks support for several key computer vision capabilities available in Python's torchvision package. This proposal aims to close the gap by implementing a wide range of torchvision datasets and models directly in R. Specifically, the project will: Implement all torchvision datasets. Add support for 5 key computer vision tasks: Object Detection, Instance Segmentation, Keypoint Detection, Semantic Segmentation, and Quantized Models. Provide native R implementations that don't rely on Python bindings, making it easier to install and use. Deliverables include tested R implementations of datasets and models, documented APIs, and example use cases. This will make R a more viable option for computer vision research and production.
This project aims to implement essential Git operations in GitLab's Web IDE, eliminating inefficient repository cloning for common version control tasks. The project will add commit amend, force push, stash, and rebase functionality. Implementation will proceed methodically, beginning with features requiring no backend changes before addressing REST API modifications. These enhancements will significantly improve developer productivity by enabling complete Git workflows within the browser, bringing Web IDE capabilities closer to VS-Code source control.
This project proposes the development of faust2clap, a tool that integrates the Faust programming language with the CLAP (CLever Audio Plugin) standard. Faust is a high-level functional language for real-time DSP, while CLAP is a modern open-source plugin format gaining traction as an alternative to VST and AudioUnit. Currently, Faust does not officially support CLAP as a target architecture. The goal is to extend the existing faust2xx framework by implementing a CLAP architecture file and a new command-line utility, faust2clap. This will allow developers to compile Faust DSP code into fully functional CLAP plugins, supporting advanced features such as per-note modulation and sample-accurate automation. Deliverables include the tool itself, a reusable architecture backend, a suite of test plugins, and comprehensive documentation. The project has been developed in close collaboration with the Faust team and aims to be merged upstream as an official component of the Faust toolchain. By bridging Faust and CLAP, this project supports open plugin standards, expands deployment options for DSP developers, and modernises the Faust ecosystem.
This project focuses on end-to-end Handwritten Text Recognition (HTR) for early modern Spanish manuscripts. Unlike traditional OCR systems, which process isolated characters or lines, end-to-end HTR captures entire documents, preserving not only the text but also structural elements such as layout and reading order. Although this approach holds significant promise for both research and practical applications, it remains underexplored, especially for historical texts. This project proposes to apply end-to-end HTR techniques to early modern Spanish manuscripts, a historically rich yet computationally challenging corpus. Leveraging recent advances in deep learning. The project aims to improve recognition accuracy on handwritten and printed texts from this period by building on models which focus on document-wide attention mechanisms, the system will be able to better handle complex layouts and diverse handwriting styles typical of early modern Spanish texts. Ultimately, this research sits at the intersection of machine learning and historical document analysis, contributing both to technical innovation and cultural preservation. By improving the accessibility of early Spanish documents, the project not only supports scholars in the humanities but also contributes to the growing field of AI-driven humanities research. The integration of cutting-edge HTR models into historical workflows can open new possibilities for indexing, searching, and analyzing large volumes of archival material in a scalable, automated fashion.
This project will enhance Makim by implementing Language Server Protocol (LSP) support for its YAML configuration files. This will introduce features like autocompletion, syntax validation, hover documentation, and custom commands directly within code editors. The project will deliver a Language Server and a VS Code extension, significantly improving the developer experience and making Makim more user-friendly.
Problem: Embedded Linux systems, particularly for In-Vehicle Infotainment (IVI), lack a user-friendly, secure application store that matches the seamless experience of mobile platforms. Existing solutions often fall short in providing curated app access, robust security, and support for diverse app types, limiting their adoption in production-ready environments. Solution: The Flatpak App Store addresses this by delivering a modern application store for embedded Linux. Built with Flutter for an intuitive UI, it leverages Flatpak for secure, sandboxed app distribution and integrates advanced features like MutualTLS, DRM playback, and Android app support via crosvm. A 22-week implementation plan ensures a scalable, production-ready solution, with cloud APIs for app management and user reviews, tailored to IVI use cases. Deliverables: A fully functional Flatpak App Store application with browsing, installation, and review capabilities. Secure architecture featuring MutualTLS, sandboxing, and secret storage. Support for Flutter, Native Linux, and Android apps, with DRM playback integration. Packaged Flatpak app and repository setup for deployment. Comprehensive documentation and test suite for IVI production readiness. This project will empower embedded Linux users with a reliable, mobile-like app store experience, enhancing IVI system functionality and security.
Kolibri's current Windows installer is outdated, difficult to maintain, relies on the unsupported IE11 engine, and lacks parity with the modern kolibri-app used on macOS. This project aims to replace the legacy installer by enhancing the existing Python-based kolibri-app to provide a first-class experience on Windows. The solution involves integrating the Microsoft Edge WebView2 engine, implementing native Windows features such as background operation via a Windows Service (using pywin32) and a system tray icon (wxPython), and creating a new native installer using InnoSetup. The application architecture will separate the UI and server processes for robustness. An automated build pipeline using GitHub Actions will be developed to produce the application bundle (via PyInstaller) and the final installer package, including code signing for releases. Main deliverables include: a functional Kolibri Windows application built from the kolibri-app codebase, a native InnoSetup installer (.exe), system tray functionality for server management, reliable background operation via a Windows service, seamless WebView2 integration, and an automated GitHub Actions build workflow for Windows artifacts.
The proposed solution introduces comprehensive tracing capabilities to the LLM4S toolkit by integrating OpenTelemetry (otel4s) for capturing detailed spans and metrics during LLM operations such as prompt construction, model invocation, and response parsing. These telemetry signals are exported in Prometheus and Jaeger-compatible formats and processed through the OpenTelemetry Collector. The data is then visualized on a unified Grafana dashboard, allowing developers to monitor performance, debug errors, and analyze execution flows across different LLM providers in real-time.
This project aims to enhance the data download capabilities of the Center for Translational Data Science's Python SDK & CLI by implementing robust, efficient, and user-friendly functionality for researchers to download and stream large biomedical datasets. By integrating with Globus for secure data transfer and optimizing performance through asynchronous processing, this implementation will significantly improve the research workflow for scientists working with large-scale biomedical data. The proposed solution will focus on maintaining high code quality through comprehensive testing, ensuring a seamless user experience, and optimizing performance for handling large datasets. The end result will be a reliable tool that enables researchers to efficiently transfer data to their workspaces for analysis, ultimately accelerating scientific discovery in the biomedical field
Many Jenkins beginners often struggle with setup issues, plugin compatibility, and troubleshooting pipeline configurations. This project proposes the development of an AI-powered chatbot integrated into Jenkins inside a plugin. This AI tool is designed to assist users by providing context-aware support based con Jenkins documentation and community resources. The assistant will be delivered as a Jenkins plugin, combining a modern React frontend, a Java backend, and a local lightweight AI model exposed via a FastAPI service. Instead of relying on fine-tuned models, the project exploits Retrieval-Augmented-Generation(RAG) approach, fetching relevant context from a vector index built from Jenkins docs and community forums, Deliverables include: a complete indexing pipeline, a functioning RAG-based LLM assistant, a modern UI, a Jenkins plugin that integrates the AI service, a robust testing coverage and a clear documentation. The final goal is to reduce the learning curve of the Jenkins users, allowing them access to a smart, embedded support tool.
LibreMesh has grown over the past decade with valuable community contributions, but some of its features now duplicate tools available in OpenWrt. This project proposes replacing key LibreMesh modules with OpenWrt-native equivalents (e.g., replacing deferrable-reboot with watchcat, and dnsmasq with odhcpd for DHCP), reducing code redundancy and improving upstream compatibility. It also aims to simplify the system by removing VLANs from routing protocols and creating a lightweight layer-2-only firmware variant for low-resource devices. The result will be a leaner, more maintainable LibreMesh aligned with OpenWrt standards. Deliverables include: migrating to upstream tools, simplifying configurations, testing in both virtual and physical environments, and engaging the community for feedback and adoption.
Musculoskeletal forces from muscles and tendons often wrap around bones and joints along curved surfaces. Current tools rely on numerical approximations for these wrapping paths, which require intensive computation. This project will extend SymPy’s mechanics module by introducing three new wrapping geometry classes: WrappingCone, WrappingEllipsoid, and WrappingToroid each providing symbolic geodesic-length calculations and endpoint tangent vectors. Using closed‑form derivations for cones, series expansions for spheroids, and local unfolding approximations for tori, the new classes will enable users to model complex biomechanical interactions symbolically, offering both exact expressions (where ever available) and good approximations. This extension will empower researchers and educators to explore musculoskeletal pathways analytically within the familiar SymPy ecosystem.
Taskwarrior Flutter is a free and open source software that aims to provide GUI for various platforms as companion for Taskwarrior CLI. Last year in house Taskserver CCSync was developed. This year aim is to make Flutter Application integration robust with those APIs. Additionally, this year project aims to deliver support for iOS and Desktops, Compatibility with Taskwarrior 2.0 as well as Taskwarrior 3.0 Complete Test coverage and Complete getx migration for state management.
Regolith is a productivity-focused Ubuntu-based desktop environment that combines tiling window managers (Sway, i3) with GNOME components for system management and GUI features. While GNOME depends on Mutter and custom Wayland protocols unsupported by wlroots-based compositors like Sway, this limits modularity and integration. To improve flexibility, this project aim to integrate the new Cosmic desktop components (cosmic-epoch), which, despite being in early alpha, offers a more modular and integration-friendly design.
Currently, the study guides are made of a single long monolithic content field which makes it hard for the learners to focus and difficult for the translators to translate. Also, worked examples can only be added to skills. This project aims to restructure the study guides to have multiple short sections and make their translations follow the pattern of other entities in the codebase. It also aims to create a WorkedExample Rich Text Editor component for the Skill and Subtopic Editor Pages.
This project enhances Pgagroal's security by implementing hot reloading for TLS certificates and configuration files, refining the vault system for better sensitive data management with backward compatibility, and adding support for database aliasing and certificate expiration monitoring. Key deliverables include robust hot reloading, vault improvements, database aliasing support, integrated certificate monitoring, along with comprehensive testing and documentation.
The Neural Extraction Framework (NEF) enhances DBpedia by extracting and integrating implicit relationships from unstructured Wikipedia text, connections that are often overlooked by traditional infobox-based extraction. The updated system employs a strict, hybrid pipeline combining deep learning and symbolic grounding to ensure semantic precision. It begins with a Gemini-based extractor that identifies candidate RDF triples directly from text, enforcing short predicates and high-confidence outputs. Subjects and objects are then strictly grounded to DBpedia URIs through Redis-backed entity linking, while predicates are retrieved via cosine similarity search over precomputed DBpedia ontology embeddings. A second LLM disambiguator refines these candidates, selecting the most contextually appropriate triple and generating structured metadata such as similarity scores and ranking. The resulting triples are clean, validated, and ontology-aligned, ready for integration into DBpedia’s RDF graph. Deliverables include the full extraction pipeline, Redis and embedding modules, validation and disambiguation components, and command-line tools for dataset-scale deployment.
SciCommons is an open-source platform aimed at improving the scientific peer review process through better user experience and web application optimization. It focuses on refining the frontend UI, following best practices, and enhancing performance. Contributors will work on UI improvements, optimizing API performance, and ensuring cross-platform compatibility.
WildBerryEye leverages edge computing (Raspberry Pi) and object detection (YOLO) to monitor pollinators like bees and hummingbirds. My project focused on developing a clean, intuitive, and responsive web-based interface to support real-time pollinator detection, data visualization, and system configuration. The final result empowers researchers and contributors to engage with environmental data in an accessible and meaningful way. Specific tasks: - Frontend Development: Continue development to enhance the user interface using React and CSS, ensuring a responsive and user-friendly design. - Backend Development: Expand functionality using Flask, focusing on efficient API endpoints and seamless interaction with the frontend. - Real-Time Communication: Implement and refine real-time updates between the frontend and backend to enhance system responsiveness. - Usability & Design Optimization: Research and propose improvements to the system’s usability, design, and overall user experience.
Extend rust-vmm crates (vhost, vhost-user-backend) to enable vhost-user device support on non-Linux POSIX systems (macOS/*BSD). The goal of this project is to make sure that we can use rust-vmm's vhost and vhost-user-backend crates on other POSIX systems besides Linux.
This project is a significant upgrade to Rocket.Chat message composer elements to provide users, AI assistance in writing messages using Context-sensitive spelling corrections, inline grammar correction recommendations, and clarity-enhancing rewording, Inline hinting are among the major features. The project also provides language translation, summarization, emoji, and tone control features. This project majorly improves the speed and clarity of message writing for users.