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.
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.
Community-driven Drupal sites currently rely on reactive, manual moderation for spam and toxic content, which is exhausting and difficult to scale. This project introduces a proactive, real-time defense system by building a fully integrated AI Content Moderation module. The solution utilizes a decoupled ContentModerator service that intercepts form submissions on the client side using debounced JavaScript, providing users with instant, WCAG-compliant inline warnings before toxic data ever hits the database. On the backend, it employs a highly performant hybrid approach, checking local administrative keyword lists before securely querying external NLP models (such as Hugging Face) via Drupal's core HTTP client. Deliverables include a production-ready module featuring an intuitive Admin UI for AI provider and threshold configuration, bulletproof server-side validation fallbacks, and comprehensive site builder documentation.
My main goal this summer is to make Adaptive Mesh Refinement (AMR) fast and efficient for P4estMesh on GPUs within Trixi.jl. Right now, whenever the mesh adapts dynamically, it triggers repeated memory allocations on the device. This creates a severe host-device synchronization bottleneck that kills performance, despite the excellent hardware support we have via KernelAbstractions.jl. To solve this, I will build an allocation-free memory manager. By implementing a multi-pool arena specifically designed to match Trixi's Struct-of-Arrays (SoA) layout, I aim to eliminate these driver-level stalls. My final deliverables include a fully functional, type-stable GPU AMR pipeline and comprehensive performance benchmarks across both NVIDIA and AMD hardware
Kolibri's QTI 3.0 viewer currently renders only Multiple Choice and Text Entry, leaving the majority of the specification's interaction types unsupported. This project extends the plugin to implement six additional types: Inline Choice, Match, Order, True/False, Gap Match, and Fill-in-the-Blank — each requiring careful integration with the existing SafeHTML rendering registry and QTIVariable response system. The core technical challenges are accessibility and interaction fidelity: drag-and-drop interactions (Order and Gap Match) require a fully keyboard-native select-to-place model as the primary interaction, with SortableJS-based drag as the pointer enhancement. Match Interaction requires a directed-pair association model rendered as an accessible grid. All six types must support RTL languages, touch devices, and low-end hardware — not as retrofits, but as first-class constraints from the start.
Problem: R remains the gold standard in bioinformatics thanks to Bioconductor. However, many data scientists prefer Python for machine learning and building production. Currently, bridging tools such as rpy2 suffer a lot from stability issues. For instance, ABI symbolic linking errors and complex S4 object mapping failures, obstructing complete integration with essential tools like DESeq2. Solution: This project aims to enhance the Rosetta library by implementing a robust three-tier API architecture. This architecture includes an easy-to-use high-level Python interface, a fine-grained control layer for advanced users, and a subprocess-based fallback mechanism to prevent core crashes. I will focus on addressing deep interoperability challenges, including S4 method distribution and cross-language type conversion. Deliverables: 1.A stable, production-ready DESeq2 and edgeR Python wrapper library. 2.A three-tier API design ensuring 100% statistical consistency with native R output. 3.During periods of high load, the subroutine falls back to the backend to ensure system stability. 4.Comprehensive documentation and a Pytest-based validation suite ensure a reproducible experimental environment.
This project accelerates the convolution core of the Active Segmentation Plugin (ASP) in ImageJ by offloading its most compute-intensive pixel operations to parallel hardware using TornadoVM. The goal is to achieve significant speedups without altering existing functionality or behavior. The approach focuses on identifying CPU bottlenecks, converting them into accelerator-friendly kernels, and executing them through a reusable TornadoVM pipeline. A strict correctness-first methodology ensures all accelerated outputs match the CPU reference in terms of boundary handling and numerical accuracy before any performance gains are considered. By integrating a robust, reusable parallel execution layer with safe CPU fallback, this work transforms ASP’s performance while preserving its reliability—laying the foundation for scalable acceleration across multiple filters and larger image-processing workflows.
The goal of this proposal is to extend HLS with a new plugin, the case split plugin, which provides a new code action (or possibly more of them) for completing the case ⟨expression⟩ of part of a case expression with the properly formatted list of alternatives, which is implied by the type of ⟨expression⟩. GHC API will be used to detect the cases missing from a (totally or partially) incomplete case expression, and to insert the missing cases in the AST, ghc-exactprint will be used for pretty-printing such missing cases in the text file.
The Checkpoint-Restore Operator manages checkpoint retention well but has no way to create checkpoints automatically. This project adds a new CheckpointSchedule CRD and controller that triggers checkpoint creation through four mechanisms: cron-based time schedules, CPU/memory resource thresholds, Kubernetes cluster events (node drain, pod eviction, preemption), and pod annotations for application-level signaling. All triggers call the existing Kubelet Checkpoint API via the Kubernetes API server proxy. Deliverables include the CheckpointSchedule CRD, a CheckpointCreator that calls the Kubelet API, four independent trigger subsystems, a TriggerManager to coordinate them, a full controller-runtime reconciler, RBAC updates, unit and BATS integration tests, and sample configuration. Together with the existing retention policies, this turns the operator into a complete checkpoint lifecycle manager — admins declare both when checkpoints are created and how long they are kept, with no custom scripting required.
Created in the early 2020’s, GNOME Crosswords became a well-liked application powered by the libipuz C library. While robust, it does not have customizable vocabulary-style puzzles. However, the implementation of a grid-generating algorithm would provide GNOME Crosswords with the ability to diversify their consumer base to even more educators. The primary focus will be to introduce a vocab-style puzzle generator to the GNOME system. The algorithms must be able to interlock words on a 2D grid tightly without breaking rules, sort inputs by length, seed the board dynamically, recursively match words to find orthogonal points to sew words together, check the constraints per surrounding cells, and score upon a placement with the failsafe to take a step back and rearrange the former word suitably. Doing so requires creating classes using GObject and GLib. A full-stack approach must accommodate for validating vocab puzzles using libipuz and Glib in the backend, and also provide an input editor for users which render a grid focused on quality using GTK4, GObject, and libadwaita in the frontend.
This project refactors Graphite to create a more generalized graphic representation of paints. It introduces dedicated Gradient and Pattern nodes, as well as updated Fill and Stroke nodes that can consume generalized graphic sources, not just the current fill and color types. The project also enables the standalone rendering of colors, gradients, patterns, and other compatible graphics as ordinary layers. The implementation will update Graphite's graphics, nodes, and Vello/SVG renderers to support gradient strokes and pattern fills. Additionally, SVG import will be supported for the MVP subset of these features. Stretch goals include broader gradient support, such as focal points, conic gradients, and gradients along strokes.
pg_stat_statements tracks query statistics across a PostgreSQL cluster, but its single-LWLock architecture creates a scalability bottleneck under high unique-query-rate workloads. When pg_stat_statements.max is undersized, deallocation and reset operations hold an exclusive lock while performing expensive operations (O(n log n) sort, full hash table iteration), blocking every backend on the server. My benchmarks on PG 19devel show 90-100% of active backends blocked on the pgss LWLock during deallocation churn. This project proposes a multi-part fix: (1) a pending-entry queue to avoid blocking on new entry insertion, (2) a restructured deallocation critical section that moves the sort outside the exclusive lock, (3) exploration of lock separation between structural changes and counter updates, and (4) an optimized reset path. Deliverables include a repeatable benchmark suite, patches for each optimization formatted for pgsql-hackers review, before/after performance measurements, and documentation.