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.
The LHC at CERN generates 30 petabytes of physics data every year. Current compression tools like LZMA treat this data like any other file and miss the statistical patterns unique to particle physics. The BOA Constrictor solves this by training a neural network to predict the next byte more accurately inside an entropy coder. The original BOA paper proved the concept works (4.03x compression on CMS data vs LZMA's 3.22x), but two gaps remain: Mamba doesn't install on Python 3.12, and nobody has compared alternative architectures under fair conditions. This project will build a benchmark suite comparing GRU, LSTM, MinGRU, Transformer, and Mamba under parameter-matched conditions. It will then optimize the best backbone using INT8 quantisation, pruning, and distillation, producing Pareto frontier plots showing compression ratio vs model size. Finally, it will explore physics-informed priors as an auxiliary loss to improve predictions. All code and results will be contributed back to the upstream BOA repository.
This project aims to modernize MetaCall's rs_loader by migrating it to the latest rustc compiler internals. The current implementation relies on outdated APIs, making it incompatible with newer Rust versions. The project will focus on updating compiler integration, replacing AST-based traversal with HIR-based extraction, and adapting to changes in rustc_driver and related components. The approach includes analyzing breaking changes, incrementally migrating core modules (lib.rs, middle.rs, ast.rs), and ensuring compatibility with modern Rust toolchains. Deliverables include a fully working rs_loader compatible with the latest rustc version, improved type and function extraction using HIR, and updated documentation for maintainability.
This project adds proper role-based access control to istSOS4 by making the web administration interface reflect the permissions already enforced in PostgreSQL through Row-Level Security (RLS). Right now, the backend enforces access correctly, but the UI does not — every user sees the same controls. This project fixes that. Each role (administrator, editor, viewer, sensor) will only see the pages and actions they are allowed to use. It also simplifies user and policy management by removing the current two-step workflow. Creating or updating a user will automatically apply the appropriate policies, reducing configuration mistakes and making the system easier to operate. To support real deployments, the project adds basic observability and debugging tools. A permission matrix shows what each role can do, and audit logs record access-related events. In addition, small utilities like permission explanation, access simulation, and change impact preview help admins understand and verify changes before applying them. The project also explores integration with external authentication providers (OIDC) so istSOS4 can work with single sign-on setups, including Grafana, without changing how permissions are enforced. Overall, the focus is to make permissions visible, predictable, and manageable for administrators.
FHIR resources are powerful but difficult to explore in practice because their data is deeply nested, inconsistent across resource types, and hard to analyze in raw JSON form. This project will enhance the existing FHIR Resource Tabular Viewer to make healthcare data easier to search, filter, and interpret for researchers, clinicians, and developers. I will improve the transformation layer that maps nested FHIR structures into stable, readable table columns, strengthen exploration features (global search, column filters, sorting, column visibility, and row-level drill-down), and extend ingestion support to additional sources, specifically local files and Amazon S3. Key deliverables are: (1) an improved and more reliable FHIR-to-table transformation pipeline for common resource types (2) upgraded table exploration and visualization workflows (3) modular data-source support for local and S3-backed datasets (4) performance improvements for larger datasets (5) expanded automated tests and documentation. The final outcome will be a more scalable, maintainable, and user-friendly viewer for real-world FHIR data exploration.
This project builds a FUSE-based virtual filesystem in Rust that exposes molecular dynamics dataset metadata as a POSIX-compatible interface for scientific workflows on HPC environments. Starting with the ATLAS dataset (1,900+ proteins), the filesystem mounts dataset metadata as a browsable directory tree where each protein entry is a directory containing its metadata as JSON files, accessible through standard filesystem operations (ls, cat, find). The architecture uses pluggable data source abstractions so additional molecular dynamics databases (mdCATH, MemProtMD) can be unified behind the same filesystem API with per-source connectors. An existing Python indexing layer crawls and normalizes heterogeneous source formats (TSV, HDF5, REST APIs) into a uniform POSIX tree structure that the Rust FUSE daemon serves. Performance is benchmarked against direct API access for metadata retrieval latency.
compiler-rt builtins provide software floating-point routines (__addtf3, __multf3, __floatsitf, etc.) for targets that lack hardware FP support. The current implementations carry two problems. First, they are under-tested, and subtle bugs survive for years. PR#119449 shows one example: __floatdixf relies on the compiler to lower a cast, but the compiler implements that cast by calling __floatdixf, creating infinite recursion. Second, the codebase mixes C and hand-written assembly across architectures, which makes maintenance and extension to new types (_Float16, bfloat16) expensive. LLVM libc implements these same operations using formally verified building blocks (FPBits<T>, DyadicFloat<N>, BigInt<N>) with exhaustive test coverage. A recent refactoring effort (#147386) made these routines available as free-standing, header-only C++ utilities. This project replaces the legacy compiler-rt FP builtins with thin C++ wrappers that call into LLVM libc's verified routines, gated behind a CMake flag so the change is transparent and non-disruptive.
Konflux container builds produce different image digests from identical source commits. The buildah task already supports reproducibility flags, but the pipelines don't wire them and there's no way to verify reproducibility automatically. This project audits all non-determinism sources in the build pipeline, wires SOURCE_DATE_EPOCH and related parameters through every pipeline variant, builds a benchmark suite of Containerfiles that exercise different reproducibility scenarios, and creates a standalone verify-reproducibility Tekton task. Deliverables: a non-determinism audit document, pipeline wiring patches, a 5+ Containerfile benchmark suite, a verification task with diffoci integration, and user/developer documentation.
Dagger.jl currently serializes all GPU tasks onto a single stream per device, leaving independent DAG branches unable to run concurrently and GPU hardware severely underutilized. This project implements multi-stream execution for the CUDA and ROCm backends by replacing the single fixed stream with a per-device stream pool, integrating stream-aware scheduling into the task dispatch layer, and replacing the global device barrier with event-based synchronization. The expected outcome is a significant reduction in end-to-end latency, improved Streaming Multiprocessor occupancy, and meaningful overlap between memory transfers and kernel execution.
This project builds an automated benchmarking ecosystem for goal-directed vision. It implements a high-priority leaderboard featuring automatic updates, submission validation, and multi-metric ranking for new Diffusion and VLM paradigms. It ensures reproducibility through versioned results for SOTA research.
Pharo provides an immersive and interactive development environment with powerful refactoring tools. However, its current refactoring workflows can be fragmented, rely on frequent pop-ups, and offer limited feedback, making them less user-friendly. This project aims to improve the usability and interactivity of Pharo’s refactoring tools, with a focus on rename operations. To achieve this, the project will develop a flexible driver and preview infrastructure that supports safe experimentation, introduce live name editing with immediate validation, and enhance the visualization of changes through a hierarchical tree structure. The expected outcomes include a streamlined refactoring workflow, a clear hierarchical preview of all changes, real-time validation of user input, and a more intuitive and interactive user experience that helps developers better understand and manage code transformations.
pgmoneta’s current storage layer is fragmented, back-ends do not share full feature parity and a single backup cannot target multiple destinations at once. This project introduces a unified storage interface that every backend implements, enabling easier maintenance and concurrent multi-backend writes. SSH and Azure backends are raised to the same capabilities as S3, while new native drivers for Google Cloud Storage (GCS) and SMB are added. Robustness is ensured by extending the MCTF framework with empirical infrastructure tests for each backend.
GCC currently supports most OpenACC directives for GPU offloading, but several features remain unimplemented or incomplete. This project targets four concrete gaps in the OpenACC implementation within GCC: - init, shutdown, and set directives (OpenACC 2.5+): Implementing the directive-form equivalents of the already-available runtime API routines, following the pattern of the existing #pragma acc wait infrastructure. - bind clause: Extending full support to C, C++, and Fortran by mapping the clause to OpenMP declare target and declare variant directives at the middle-end level or implementing OpenACC specific code. - device_type clause: Filtering clauses in the GIMPLE IR linked list based on the target device type at compile time using the ACCEL_COMPILER variable. - cache directive: Moving beyond the current no-op behavior by emitting prefetch instructions and/or placing data in low-latency memory using existing GCC prefetch infrastructure and OpenMP memory traits for certain use cases. Additionally, once core tasks are complete, the project will survey newer OpenACC specification features, producing a structured list of unimplemented functionality with prioritized implementations and documentation to ease future contributions. Deliverables include upstream patches for each directive/clause with test suite additions for C, C++, and Fortran, and documentation updates to the relevant documentation files.
GIMPs typographic engine is currently limited by legacy GTK3 and Pango constraints. This project overhauls the text backend by directly integrating HarfBuzz to extract font data and advancing GIMPs experimental text layout library. Deliverables include migrating the font chooser to modern GTK list models, grouping fonts by WWS families, and introducing modular on canvas UI controls for variable font axes and OpenType features.
This project adds pairwise causal discovery methods to pgmpy, focusing on inferring causal direction between two variables from observational data. It includes implementations of ANM, IGCI, and Bivariate LiNGAM under a simple, unified interface, along with an HSIC-based independence test and basic benchmarking using the Tübingen CauseEffectPairs.
JabRef, comprehensive literature management software, currently supports both handling metadata and text-based PDF documents. However, a significant limitation arises with scanned PDFs, particularly historical articles, which are not text-searchable due to their image-based format. This project aims to bridge this gap by integrating advanced OCR (Optical Character Recognition) technology, enabling full-text search in scanned PDFs.
JPF currently cannot fully analyze Java 17 programs that use sealed classes and records — two features now standard in modern Java. This project completes Java 17 support in jpf-core by fixing sealed class enforcement, adding full record support (classfile parsing, metadata storage, and execution), and producing a Java 17 audit document that maps all remaining gaps for future contributors. The work targets the java-17 branch and builds on an existing contribution to the codebase.
GDB-UI currently supports only one user at a time because the backend shares a single global GDB controller across all requests. When two users debug simultaneously, the second session silently destroys the first with no error or warning. This proposal implements a three-phase solution. Phase 1 replaces the global controller with a thread-safe SessionManager that gives each user their own isolated GDB instance via a UUID session_id. A working implementation is already open as PR #131 with 15 passing tests, security fixes, and a live demo page. Phase 2 introduces WebSocket streaming with a per-session reader thread architecture so GDB output reaches the frontend in real time without blocking the server. Phase 3 moves each project into an isolated Docker container using the Docker SDK exec_start socket API for interactive GDB attachment, solving file descriptor exhaustion at the OS level. Deliverables: merged SessionManager with full test coverage, WebSocket streaming with reconnection handling, Docker sandbox with resource limits, security audit, and handover documentation.
The current Wikifile Transfer tool is constrained as a single-transfer utility. This creates highly repetitive manual work for contributors migrating non free media across sister projects, lacks durable upload history for failure diagnosis, and misses automated category localization. This project evolves the tool into a robust, job based batch transfer pipeline using Python, Flask, Celery, and React. The solution implements a durable MySQL state machine to track transfer lifecycles and ensure fault tolerance. Key deliverables include: 1) A batch upload API and React UI orchestrator, 2) A persistent History Dashboard with safe, targeted retry logic for failed jobs, 3) Automated, non destructive category localization using MediaWiki APIs, and 4) Comprehensive E2E and backend testing using Cypress and Pytest. This enhancement will eliminate manual bottlenecks and save thousands of volunteer hours across Indic language communities.
Debusine currently only shows task logs after a task has fully completed. This means developers working with long-running jobs (such as package builds or test pipelines) have no way to monitor progress in real time or catch failures early. This project adds live log streaming to Debusine. The implementation follows a four-stage pipeline. On the worker side, the sub-process runner will be extended to capture stdout and stderr incrementally as a task runs, sending each line to the server over the existing WebSocket connection rather than waiting for the task to finish. On the server side, a handler will receive these lines and write them to a per-task Redis Stream, providing a persistent, ordered, low-latency buffer that supports multiple simultaneous readers. A server-side view will then expose these log lines to browser clients via Server-Sent Events or a WebSocket endpoint. As a stretch goal, the Debusine web UI will subscribe to that endpoint and display lines appearing on the task page in real time, with no page refresh required. Deliverables: - Worker-side incremental log capture and WebSocket emission, with full test coverage - Server-side Redis Stream ingestion, per-task key namespacing, and post-task flush to PostgreSQL - A server view that streams log lines to browser clients for running tasks - A browser-side UI update that shows live output on the task detail page using plain JavaScript, without any frontend framework
This project develops an open-source system to visualize and explore complex data from underwater ROVs, integrating panoramas, sonar, and point clouds into a Google Street View–like interface. It enables advanced tasks like mission planning, site re-identification, and live data registration, while supporting evolving scientific goals, new data modalities, and multiple vehicle types for long-term underwater research.
This project will develop a standardized Python pipeline to evaluate submissions to OSIPI perfusion imaging challenges for ASL and DSC DCE MRI methods. Researchers use different computational approaches to generate perfusion parameter maps, but there is a need for a consistent system that can validate submitted datasets run submitted code and calculate evaluation metrics in a reliable and reproducible way. The proposed pipeline will accept challenge submissions that include parameter maps and the code used to generate them. It will first validate that submitted files follow expected structures and medical imaging formats such as NIfTI and BIDS. The system will then run the submitted workflows in a controlled environment and calculate evaluation metrics such as RMSE bias and coefficient of variation. Results will be organized into reports and visualizations that allow researchers to compare the performance of different methods against reference datasets. The pipeline will be implemented in Python and designed to support both ASL and DSC DCE challenge frameworks. The architecture will focus on modular design so new datasets metrics and evaluation procedures can be added in the future. Automated testing validation checks and documentation will be included to ensure the system is reliable and easy for researchers to use and extend. This project will help improve reproducibility and transparency in perfusion imaging research by providing a clear standardized framework for benchmarking computational methods used in quantitative MRI.
This project aims to resolve significant performance bottlenecks in MariaDB’s INFORMATION_SCHEMA when dealing with a high number of databases or tables. Currently, many INFORMATION_SCHEMA queries require the creation of internal temporary tables and expensive filesystem scans. The proposal focuses on two major optimizations: MDEV-31342: Implementing a mechanism to bypass temporary table creation for simple queries, allowing results to be streamed directly to the client. MDEV-31535: Optimizing the directory scanning process by leveraging the in-memory privilege cache to filter database/table visibility, thereby reducing redundant and slow I/O operations. Combined, these changes will drastically improve the responsiveness of metadata queries in large-scale MariaDB deployments.
This project focuses on enhancing the scanning capabilities of Nettacker by introducing payload-based probing techniques for service detection. By sending protocol-aware probes instead of generic requests, the scanning engine will be able to identify running services more accurately and extract version information where possible, significantly improving reconnaissance capabilities. Overall, the proposed improvements will strengthen Nettacker's ability to perform reconnaissance scan and vulnerability discovery while expanding its coverage of vulnerabilities listed in the CISA Known Exploited Vulnerabilities (KEV) catalog and improving test coverage.
The goal of this project is to introduce more locking protocols, in particular Multiprocessor Priority Ceiling Protocol (MPCP) and Distributed Priority Ceiling Protocol (DPCP), to RTEMS to be used by semaphores, as well as testsuites for the two protocols. This allows users to choose different locking protocols to use can be more practical depending on their application.