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.
Video frame interpolation (VFI) refers to the process of increasing the framerate or frames-per-second (FPS) of digital media beyond the initial framerate that is explicitly available (e.g., interpolating 24fps video to 60fps video), and is desirable to be done in real-time using GPU-accelerated algorithms to allow for use in media players such as VLC Media Player. This technique is not available to a broad audience through open source software, with implementations either being proprietary, unsuitable for real-time use, or unsuitable for use in a media player setting. We will solve this problem in libplacebo, VideoLAN's GPU-accelerated video processing library, by implementing a motion compensation-based VFI algorithm, a class of VFI algorithms well suited for real-time performance. This algorithm will require two stages: motion estimation (predicting the motion of pixels from one frame to the next), and motion interpolation (using motion estimates to estimate an intermediate frame between the two). This algorithm will be robust to common VFI challenges, using an image pyramid for large motion handling, and bidirectional motion estimation for occlusion handling. We will clearly document VFI in libplacebo to enable easy integration into software projects, such as media players. We will document the performance, the speed and accuracy of our VFI implementation, using common benchmarks from literature such as Adobe240FPS, or the Xiph dataset, using metrics such as SSIM as well as visually identifying artifacts, to better understand the computational efficiency of our algorithm (performance on 1080p vs 4k resolution, performance when interpolating multiple frames 24->120fps) and accuracy under varying input (large motion caused by high resolution).
This plan aims to improve dora-rs's getting-started documentation by creating a comprehensive learning system—including written tutorials, video guides, and runnable code examples—that enables new users to complete their first project within 2-3 hours. Leveraging prior contributions to the dora-rs ecosystem and experience producing AI-assisted programming tutorials, the applicant plans to deliver 8 milestones across 12 weeks: basic setup and rerun simulation before midterm (July 10), followed by multimodal model integration, LLM-based action planning, and adora+octos advanced features before the final deadline (August 24). All outputs will be published as open-source documentation and bilingual video tutorials on GitHub, Bilibili, and YouTube.
This project focuses on improving the TaskWarrior Flutter mobile application by reducing technical debt, improving the Rust–Flutter integration, and expanding core TaskWarrior functionality on mobile platforms. The current codebase contains legacy synchronization components, incomplete Rust FFI features, and an unstructured project layout that makes maintenance and feature development difficult. The project will remove the deprecated CCSync synchronization layer and unify synchronization through the TaskChampion Rust backend. The tc_helper Rust library will be refactored to improve build configuration, modular structure, cross-compilation, and to expose missing task attributes to the Flutter application. The Flutter project will also be reorganized into clear modules separating legacy Taskwarrior 2.x code from the TaskChampion implementation. Additionally, a mobile reporting engine will be implemented to support Taskwarrior-style filtered reports and user-defined configurations. A GitHub Pages website with automated nightly build tracking will also be created, along with targeted UI and UX improvements based on community feedback. Deliverables include synchronization refactoring, Rust library improvements, Flutter project restructuring, a reporting engine, project website, and UI/UX enhancements.
The VINE project at Iron Horse Vineyards collects continuous agricultural data through LoRaWAN sensors (soil moisture, temperature, CO2, weather) and multispectral drone imagery, but lacks the ML models to turn this data into actionable predictions. This project builds three interconnected model tracks for the VINE precision agriculture platform, all trained on NRP's GPU clusters. First, predictive irrigation scheduling: time-series forecasting models (ARIMA, Prophet, LSTM) that predict soil moisture at multiple horizons and recommend when to irrigate before crop stress occurs. Second, plant health computer vision: CNN-based models (fine-tuned ResNet/EfficientNet) that analyze multispectral drone imagery to classify plant stress, detect pest damage, and estimate yield, producing spatial health maps per vineyard block. Third, harvest timing prediction: forecasting models (XGBoost, LSTM) that predict optimal harvest windows from sensor data, weather, and historical records. Deliverables: (D1) data ingestion and feature pipeline for sensors, imagery, and historical records, (D2) irrigation scheduling models with decision layer, (D3) plant health CV models with spatial health maps, (D4) harvest timing models, (D5) systematic model evaluation report with ablation studies, (D6) Dockerized inference services deployed on NRP Kubernetes with REST API, (D7) documentation and bi-weekly blog posts.
BRL-CAD is a battle-tested Constructive Solid Geometry (CSG) engine, but it currently lacks a native, bidirectional interface for headless command execution, creating a massive barrier for modern web integrations and AI agents. This project proposes building BRL-CAD’s first native, extension-agnostic C++ Local IPC (Inter-Process Communication) API. By securely binding a stdio-based pipe listener to the main event loop and leveraging native libbu utilities for memory-safe string parsing, this infrastructure will allow users to safely pipe commands directly into the libged database engine. Designed with a "generic passthrough" architecture, it avoids hardcoding 400+ command schemas and ensures frictionless portability to BRL-CAD’s upcoming MOOSE/Qt interface. Alongside this foundational API, the project delivers a robust Model Context Protocol (MCP) server to establish BRL-CAD's first native Agentic AI integration. Operating externally as decoupled Python-based FastMCP middleware, this daemon bridges the legacy C-engine with modern Large Language Models. Rather than embedding a bulky AI chatbot inside MGED, the user interacts through their preferred external MCP client (like Cursor IDE or Claude Desktop), which routes commands directly into BRL-CAD's new background IPC pipeline. This empowers users to seamlessly query native documentation, automate batch database tasks, and debug spatial relationships using conversational commands, drastically lowering BRL-CAD's onboarding friction.
Graph Neural Networks (GNNs) rely on message passing, traditionally implemented via a gather/scatter mechanism. In GraphNeuralNetworks.jl, this approach materializes dense feature matrices on graph edges, leading to severe memory bottlenecks and reduced performance as graph sizes scale. This project addresses this limitation by redefining message passing as non-materializing Sparse Matrix-Matrix Multiplications (SpMM). By treating the graph as a sparse mathematical operator, this project will unlock significant computational efficiency and memory savings on CUDA GPUs. The core objectives include integrating COO storage, upstreaming patches to CUDA.jl, and refactoring the GNNlib API. To ensure continuous momentum during upstream review cycles, the project features a secondary track focused on upgrading the Automatic Differentiation (AD) pipeline by fully integrating Mooncake.jl and Enzyme.jl, alongside expanding the ecosystem with new datasets and new tutorials / improved documentation.
Description: Project will mainly be focusing on automation of Documentation Comments (javadoc) guidelines by Checkstyle Checks. Reliable comments parsing was a major improvement in Checkstyle during GSoC 2014 and 2025, archived results need to be reused to reliably implement automation of Javadoc best practices. Separate configuration file with newly created Checks need to be created. Best practices in documentation make sense not for all projects. Javadoc validation matters only for library projects that need to expose online documentation in web publicly. Deliverables: The result of this project will be a configuration file with the maximum possible coverage of Comment style guide. Report should look like Google's Java Style Checkstyle Coverage. If there will be time left we can focus on coverage of guidelines from https://blog.joda.org/2012/11/javadoc-coding-standards.html
The Qubes PDF converter safely sanitises untrusted PDFs by rendering them inside a disposable VM. However, other risky file types (documents, spreadsheets, images) lack equivalent protection. This project generalises the converter into a plugin-based architecture with per-format qrexec services and minimal DispVM templates. Key features: • New qvm-convert-file entry point with MIME-based routing • Document & spreadsheet conversion via LibreOffice → existing bitmap pipeline • Image sanitisation via decode + re-encode (metadata stripped) • Audio/video conversion via ffmpeg (stretch goal) • Full backward compatibility with qvm-convert-pdf Deliverables: D1: Plugin architecture + MIME dispatch D2–D3: Document & spreadsheet converters D4: Image sanitiser D5: Media converter (stretch)
The current reuse workflow in FOSSology provides a powerful mechanism to copy license clearing decisions from a previously analyzed upload to a newer version. However, this process remains largely mechanical and opaque, offering little insight into what has changed between versions after reuse is applied. As a result, users must manually inspect differences to understand the impact of reuse, which becomes increasingly difficult for large codebases and frequent updates. To address this limitation, this project proposes the development of an Enhanced Reuser Agent that adds an intelligent analysis layer on top of the existing reuse workflow. The agent runs automatically after scanners complete and reuse decisions are applied, comparing the previously cleared upload (v1) with the new upload (v2). It generates insights such as a diff-aware file tree, license comparison, aggregated statistics, and a risk-level summary. In addition, a Smart Reuse (Suggested Matches) mechanism automatically identifies and recommends similar previously-cleared uploads, reducing the manual effort required to search for suitable reuse candidates. By providing a clear and interactive view of structural and license-level changes, along with proactive reuse suggestions, the system enables users to better understand the outcome of reuse and efficiently refine decisions where needed. This transforms reuse into a more transparent and insight-driven process, reducing manual effort and improving overall usability while remaining fully compatible with the existing FOSSology workflow.
This project implements an anova classdef for the GNU Octave statistics package, providing a unified object-oriented interface for one-way, two-way, and N-way analysis of variance. The anova class delegates core computation to the existing anova1, anova2, and anovan functions, preserving their tested logic while exposing a clean, MATLAB-compatible OOP API with properties (Coefficients, anova table, fitted values, residuals, diagnostics) and methods (summary, multcompare, plotDiagnostics, predict, getEffectSizes). The class stores model state, enabling interactive post-hoc workflows without refitting. Beyond the classdef, the project delivers targeted performance improvements to the underlying functions: vectorizing loop-heavy group statistics in anova1 with accumarray, vectorizing anova2 SSE computation, reducing memory in anovan interaction column construction, and adding NaN handling to anova2. Deliverables: (1) anova classdef with constructor, properties, and core methods, (2) summary and display methods with formatted ANOVA table output, (3) multcompare method for post-hoc pairwise comparisons, (4) plotDiagnostics method for residual and leverage plots, (5) performance optimizations to anova1, anova2, anovan internals, (6) NaN handling for anova2, (7) comprehensive BISTs and Texinfo documentation, (8) benchmark suite. All computation reuses existing functions with no architectural rewrites.
VisualCircuit currently relies on hard-coded monolithic JSON blocks, making it difficult for the community to share and extend custom logic. This project solves that bottleneck by building a curated, reusable block marketplace hosted on GitHub Pages with automated CI validation workflows. Deliverables include the standalone marketplace site, a slim frontend integration layer for VisualCircuit, automated documentation publishing via GitHub Actions, and two end-to-end robotics applications demonstrating the complete workflow.
LowType currently relies on shim methods to bypass type checking when disabled, adding persistent runtime overhead on every method call through define_method closures and repeated Lowkey proxy lookups. This project eliminates that overhead entirely by rewriting typed methods directly onto the class using class_eval, producing plain untyped Ruby methods indistinguishable from hand-written code. Deliverables include removal of the shim execution path, class_eval based method rewriting integrated with Lowkey export methods, edge case handling for kwargs and defaults, benchmark results using benchmark-ips, and full test and documentation coverage. A working prototype already exists with real benchmark results showing 1.8 to 2x improvement over the current shim.
Spectra.jl already handles UV, optical, and IR spectra, but has no capability for loading spectra like X-ray and gamma-ray, as they are different from UV/optical/IR spectra. X-ray astronomy (and other high energy fields) typically operates on spectra that are binned into channels by the measurement device. An instrument response matrix (RMF) is required to map detector channels to physical energies, and an ancillary response file (ARF) provides the telescope's effective collecting area, and both are needed to correctly convert raw channel counts into physical flux. SpectralFitting.jl already contains an OGIP parser that handles these formats. It has been agreed upon that the correct long-term architecture is for the spectral types to live in Spectra.jl, with SpectralFitting.jl eventually depending on Spectra.jl rather than duplicating data structures. Beyond data loading, observers also need a standard set of tools before any science can be done, such as rebinning according to different heuristics, adjusting the wavelength or energy shifts, or converting between common units. This project implements those tools in Spectra.jl as well, making it easier for users of Spectra.jl.
Open Food Facts Explorer is a next-generation frontend for exploring and contributing to the Open Food Facts ecosystem, built with modern technologies like SvelteKit. It aims to achieve full feature parity with the main platform by keeping it modern, scalable and contributor-friendly. This project aims to enhance Explorer by adding multi-platform support (Open Food Facts, Open Beauty Facts, Open Pet Food Facts, and Open Products Facts), improving product addition and editing workflows, integrating Open Prices and moderator only features and tools like Nutri-Patrol directly into the app. It will also introduce enhanced search capabilities and Robotoff-powered features to assist contributors. From a technical perspective, the focus will be on decoupling the frontend from the backend by strengthening the SDK usage, and leveraging reusable web components where appropriate while maintaining SvelteKit’s SSR benefits. “Transform openfoodfacts-explorer from a food-only prototype into a complete, multi-platform contribution tool that achieves feature parity with the main OFF website"
The predictive power of game-theoretic analysis in n-person games is frequently undermined by the vast multiplicity of Nash equilibria. VISION: This project will implement the globally convergent, everywhere differentiable homotopy algorithm proposed by Herings & Peeters (2001) into the Gambit C++ core and expose it via the PyGambit API. It will be the first algorithm in Gambit repository that reaches a Nash Equilibrium taking into account a subjective Prior, which is critical for providing realistic context to game-theoretic models. DELIVERABLES: • Securing the Path-Tracking Foundation (Issue #492): Based on my mentor's feedback regarding my previous work on the logit_solve path-following methods, I will implement a configurable perturbation system, add a bifurcation logging mechanism. • Variable Transformation & System Definition. • Analytical Jacobian & Path Tracking Engine: I will abstract the existing Allgower-Georg path-tracking code to work with the H&P algorithm, ensuring that it can be easily substituted in the future by alternative solvers such as HOMPACK. I will also code the analytical Jacobian matrix. • PyGambit API Integration: I will write the necessary bindings to expose the C++ solver to Python. • Testing & Performance Benchmarking.
This project aims to enhance the FURY documentation experience by making it more reliable, accessible, and visually engaging for both users and developers. Currently, the documentation build process generates multiple warnings, some tutorials fail to produce static images consistently, animated tutorials are not natively supported, and parts of the website layout can be improved for better usability. To address these issues, I plan to streamline the documentation build pipeline by resolving existing warnings and improving the reliability of tutorial image generation. I will also introduce native GIF support to enable animated tutorials and interactive visual examples. In addition, I will redesign key parts of the documentation website’s UI/UX to improve readability, navigation, and overall user experience. The key deliverables of this project include a clean and warning-free documentation build process, robust static image generation for tutorials, native support for GIF-based animated examples, and a refreshed documentation interface that makes FURY easier to learn, explore, and contribute to.
Rocket.Chat relies on Agenda to schedule and run critical background jobs, but administrators have no way to monitor or manage them without directly querying MongoDB. This project will build a dedicated Agenda Jobs Admin Page inside the Rocket.Chat admin panel, giving administrators full visibility and control over background jobs. The implementation will deliver a service layer deriving job status from existing Agenda metadata, six REST API endpoints, and a React admin UI built with Fuselage showing job status, execution history, failure details, and one-click actions to trigger, disable, or enable jobs.
This project extends the gfpop R package to support time-dependent constraints. Instead of using a fixed constraint graph, the graph can change at each data point based on a user-defined rule function. This makes it possible to express models like LOPART and labeled up-down peak detection within a single framework. Deliverables include the R API extension, C++ implementation, oracle-validated LOPART model, a 6-rule up-down model with label support, and a user-facing vignette.
This project aims to finalize stalled pull requests and implement high-priority features in the Zulip web application, focusing on messaging, search, settings, and backend performance. In messaging and compose UI, the project aims to enable collaborative message editing, allow seamless messaging to unsubscribed channels with proper warning banners, and fix UI jitter during channel subscriptions. In search and settings, the project introduces wildcard, topic, and group-user mentions, revamps alert word notifications to integrate with topic-following, and adds Markdown support to custom profile fields. Finally, it optimizes backend performance by significantly reducing database queries for direct messages, stabilizing password reset email flows, and cleaning up legacy bot configuration logic.
Apache Mahout's QDP is a GPU-accelerated quantum state encoding library bridging Rust, CUDA, and Python — yet its contributor experience lags behind its technical ambitions: unsafe blocks lack // SAFETY: justifications, public APIs are undocumented, Clippy warnings accumulate, and neither cargo doc nor Python API generation is enforced in CI. This project tackles all three layers in 12 weeks. Phase 1 narrows unsafe blocks with proper safety documentation, achieves 100% RFC 505-compliant API coverage, eliminates all Clippy warnings, and adds ≥25 GPU-independent unit tests. Phase 2 builds an automated Sphinx pipeline for the Python (qumat/) API and validates Rust ↔ Python interface consistency. Phase 3 fixes broken links on the Docusaurus site and integrates both cargo doc and Python doc generation into CI. Key deliverables: refactored unsafe blocks across 4 core files, 100% Rust API doc coverage, zero Clippy warnings, ≥25 new unit tests, automated Python API docs, a rustdoc.yml CI workflow, and a contributor documentation guide — creating a unified, drift-resistant documentation experience across QDP's Rust and Python interfaces.
LibreOffice Writer's internal layout engine is extremely intricate and historically dense. This means that attempting to modernize and refactor it is extremely difficult without comprehensive automated tests that account for every possible case. This is precisely why this project is shifting away from conventional bug hunting and instead focusing on an analytical and metric-driven Quality Assurance approach. By utilizing gcov and lcov, it is possible to automatically determine which C++ execution branches in the core layout module (sw/source/core/layout/) are not yet tested. By reverse-engineering test documents that specifically invoke these branches, it is then possible to create comprehensive CppUnit tests that utilize parseLayoutDump() and XPath queries to mathematically validate and "lock in" the correct internal XML layout tree representation. The final deliverables will be continuous lcov coverage reports that demonstrate quantifiable metrics, custom-engineered test documents (.odt/.docx), and dozens of high-quality C++ layout tests that will be merged into sw/qa/extras/layout/. This project will create a comprehensive safety net that is significantly cheaper, easier, and safer for all core developers.
The torchvision package in the mlverse ecosystem provides essential tools for computer vision workflows in R, including datasets, transformations, and model utilities. While the ecosystem has matured significantly, a key limitation remains in the performance of certain core operations, particularly in detection pipelines. Functions such as Non-Maximum Suppression, bounding box transformations, and proposal filtering are currently implemented at the R level, which introduces inefficiencies when working with larger inputs or real-time use cases. This project aims to address that gap by moving performance-critical components into a native C++ backend using torchvisionlib. The approach will focus on identifying the parts of the pipeline that are actual bottlenecks, implementing them in C++ with careful attention to memory usage and batching, and integrating them back into torchvision without changing the user-facing API. Rather than rewriting everything, the work will prioritise targeted optimisations that have a measurable impact on end-to-end performance. In addition to backend improvements, the project will include the implementation of at least one modern computer vision model family, such as YOLO, using the optimised components. If time permits, support for an additional model (e.g., RT-DETR) will also be explored. These models will be integrated into the existing ecosystem with consistent APIs and working examples. The main deliverables of this project are: a set of optimised C++ implementations for core detection operations, their seamless integration into torchvision, at least one fully functional model pipeline built on top of this backend, and supporting documentation and benchmarks demonstrating performance improvements. The goal is to make torchvision not just feature-complete, but efficient enough for practical, large-scale use.
EKO (Evolution Kernel Operators) is a foundational Python library used in high-precision particle physics that currently faces performance bottlenecks as computational demands grow. This project aims to "oxidize" EKO by maturing its initial Rust port into a production-ready, highly optimized backend. The solution focuses on minimizing cross-language friction by designing a zero-copy Python-Rust interface utilizing PyO3 and rust-numpy, implementing stateful workspaces for zero-allocation loops, and optimizing data layouts for CPU cache locality. Key deliverables include seamless Python-Rust integration, automated CI/CD packaging via Maturin, rigorous accuracy and memory benchmarking against the legacy Python codebase, and the establishment of stable C-ABI headers to allow direct ingestion by C++ and Fortran tools within the broader physics ecosystem.
A major goal for MDAnalysis 3.0 is the “support for streaming and cloud stor- age.”1. A natural extension of this object simply adding the ability to “fetch” more things for the internet. A typical molecular dynamics workflow involves using a shell script to programmatically retrieve online molecular dynamics ob- jects to save on disk, and then running an analysis script. This is rather inconvenient especially considering python strength as a “glue language.” While the user can always download an external library to perform the same functionality, the benefits of integrating downloaders or fetchers should be read- ily apparent. Integrating fetchers would provide a “batteries included” solution to this problem and such code would be inherently more readable and pythonic. Having code where every statement is readable and precise is one of the greatest strengths of Python compared to other languages. Rather than focusing on unfamiliar external libraries or nasty shell scripts, this approach would allow the user to focus on the impor- tant thing. The science! Thus, this proposal seeks to enhance the fetch module in three ways: live downloading of structures, live downloading of trajectories, and providing utilities to ensure file integrity.