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.
GNU Radio’s current CI system relies on software-based testing, which cannot capture real-world SDR behavior and hardware-specific issues that arise under actual RF conditions. This limits the reliability of validating signal processing blocks before deployment. This project proposes a Hardware-in-the-Loop (HIL) Continuous Integration framework using CortexLab to extend GNU Radio’s CI pipeline with automated hardware validation. The system detects hardware-relevant changes in pull requests, maps modified blocks to predefined test configurations via a registry, and generates experiment artifacts (tx.py, rx.py, analyze.py, scenario.yaml) dynamically. To ensure efficient resource usage, the pipeline introduces a maintainer-controlled HIL execution step, allowing prioritization of critical PRs instead of fully automatic triggering. After reserving SDR nodes, a lightweight validation test is executed to verify hardware readiness before running full experiments. Each experiment is executed iteratively across multiple input configurations, and results are analyzed using block-specific metrics such as frequency error, amplitude deviation, SNR, BER, and stability. The system produces structured outputs that determine a final PASS/FAIL decision integrated into the CI workflow. Robust error handling mechanisms are included to manage failures in node allocation, execution, and result analysis.
KomaMRI.jl is a high-performance Julia package for MRI simulation and differentiable workflows, but its use is currently limited to the Julia ecosystem, creating a barrier for the broader Python-based scientific computing and machine learning community. This project introduces komamripy, a lightweight Python wrapper that exposes KomaMRI’s core simulation and differentiable capabilities through a minimal, intuitive API. The approach leverages Julia–Python interoperability to map data structures between environments, incorporates Julia-side precompilation to reduce first-use latency, and enables flexible GPU backend support across CUDA, AMDGPU, Metal, and oneAPI. The project will deliver a pip-installable Python package with CI-tested builds and automated releases, precompiled simulation and autodiff workflows, cross-platform GPU backend selection, and a validated end-to-end example demonstrating differentiable RF pulse optimization using JAX, along with supporting documentation and example scripts.
Webpack's extensive API definitions are currently locked inside raw types.d.ts files, creating a significant manual maintenance burden to keep the public documentation synced. My proposal solves this by building an automated, version-aware CI/CD pipeline. I will extract TypeScript ASTs using TypeDoc, format them via typedoc-plugin-markdown with a custom webpack-doc-kit theme, and integrate them into @node-core/doc-kit. The final deliverable is a polished, searchable React-based UI that matches Webpack's visual identity, completely removing the manual documentation overhead from the core team.
This project delivers an integrated framework to optimize cost, strengthen governance, and improve security operations for Apache Beam resources on Google Cloud Platform (GCP). Key deliverables include: GCP Cost Optimization for Taxi Pipelines: A targeted optimization effort for NYC taxi-related Beam tests and examples to reduce unnecessary Pub/Sub and Dataflow consumption. The work includes execution-bound controls, reusable datasets/snapshots, and safer cleanup practices to preserve reproducibility while lowering operational cost. GCP Resource Governance via IaC: A Terraform-based Infrastructure as Code baseline to define and enforce labels, TTL metadata, ownership fields, and lifecycle policies for high-cost services (BigQuery, Dataflow, Compute Engine, Artifact Registry, and Cloud Storage). This enables a version-controlled, auditable, and repeatable infrastructure governance model. Automated Inventory and Drift Detection: A continuous inventory and compliance pipeline integrated with GitHub Actions, BigQuery, and dashboards. The system will collect resource state, classify orphaned/non-compliant assets, run Terraform validation/plan checks, and detect drift between current infrastructure and declared baseline. Service Key Compliance Monitoring: An operational monitoring flow for service account keys that tracks rotation health, propagation status, TTL violations, and suspicious usage signals, with automated reporting and alerts. Safe Remediation Workflows: Disable-then-delete playbooks executed first in dry-run mode and later in controlled execution, providing secure and traceable cleanup of obsolete resources based on validated policy outcomes.
FFmpeg can send WebRTC streams via WHIP but has no way to receive them. This project fills that gap by implementing a WHEP demuxer in libavformat, built on top of the existing WHIP code. The plan is to reuse SDP, ICE, DTLS, and SRTP as much as possible and just flip the direction. The end goal is making ffplay whep://server/stream work, with a clean patch series ready for ffmpeg-devel.
Astropy’s Python API is well-tested, but its underlying compiled layer (C, C++, Cython) lacks isolated testing. Because performance-critical extensions are currently only tested indirectly via high-level Python calls, deep bugs can easily be masked. This testing blind spot also blocks major architectural milestones, including the APE low-level package split, the Meson build system migration, and support for Python 3.15 free-threaded builds. This project will build a dedicated test suite to exercise each compiled extension module directly, entirely bypassing the public Python API. By engineering methods to probe these modules in isolation, including resolving complex runtime circular dependencies like `unit_list_proxy.c`; this work will establish a robust, reliable testing boundary between Python and the compiled code. Deliverables: C-API Audit: A mapped testing surface for active compiled extension modules. Isolated Test Suites: Direct pytest suites for compiled modules in astropy/table, time, timeseries, utils/xml, wcs, and erfa. Dependency Resolution: A C-level refactor (or minimal Python stub) to fix the `unit_list_proxy.c` circular dependency. Documentation: A new TESTING_EXTENSIONS.rst guide in Astropy's docs detailing how to run and extend these direct tests.
The project should fix the N+1 queries problems across the project with DataLoaders. The file run-ci-cd.yaml should will be split into 5 files and the docker layer will be removed.
This project develops agent-accessible CLI tooling for the Julia Bayesian ecosystem, delivering three main components: DoodlePPL CLI for model validation, code generation, sampling, and diagnostics with structured JSON output, MCMCChains.js, a TypeScript npm library enabling MCMC diagnostics and visualizations in the browser and TuringCLI, a command-line interface for Turing.jl that provides machine-readable JSON outputs, with all three deliverables building upon and extending the GSoC 2025 work on DoodleBUGS.
Open-weight LLMs are reproducible in principle but not verifiable in practice. You can download weights, but you cannot prove what data they were trained on or whether they were modified later. This project closes that gap by building a training pipeline where identical configurations produce identical model states, and any deviation is cryptographically detectable. A key insight from my experiments is that while training computation can be deterministic, PyTorch’s .pt serialization breaks verification: identical weights can produce different checkpoint files. This project resolves that by verifying tensor-level state using byte-stable formats rather than file-level artifacts. The deliverable is a 1B–3B model trained on a pinned Wikipedia dataset, along with a public manifest that enables independent reproduction and audit.
This project adds a Ninja build backend to DUB, the D package manager and build tool used by the D ecosystem. Currently, DUB primarily drives builds via direct compiler invocations. This limits incremental build performance, parallelism, and integration with modern build tooling. The proposal introduces a backend that allows DUB to generate Ninja build files and delegate compilation to Ninja. This enables faster incremental builds, better dependency tracking, improved parallel execution, and easier IDE/toolchain integration.
Building modern Text User Interfaces (TUIs) often forces developers to choose between writing complex, low-level terminal sequence code or adopting restrictive, framework-specific solutions. This project addresses this fragmentation by bringing the universally beloved, declarative Shoes GUI DSL (via the Scarpe project) to the terminal environment, allowing developers to build complex CLI applications intuitively. The proposed solution leverages a robust, dual-language architecture. The frontend consists of a pure-Ruby DSL where developers define UI layouts and business logic. The backend is a custom-built, high-performance Rust rendering engine responsible for flexbox-like layout calculations, double-buffered differential rendering, and non-blocking event polling. These two layers communicate seamlessly in real-time through a memory-safe C-FFI (Foreign Function Interface) bridge, ensuring the Ruby VM is never blocked by terminal I/O. By the end of the project, the clearly defined deliverables are: 1) A Universal Low-Level TUI C-API: A standalone Rust rendering engine exposing a clean C-ABI, making it usable not just by Ruby, but by any FFI-capable programming language. 2) The scarpe-tui Ruby Backend: A complete mapping of core Shoes elements (stack, flow, button, edit_line, styling, and clipping) to the terminal grid. 3) An Advanced Showcase Demo: A complex, asynchronous CLI application (inspired by "Claude Code") featuring scrollable histories and bidirectional data flow, proving the framework's readiness for real-world production use. 4) Comprehensive Documentation and Test Suites: Ensuring maintainability and easy community adoption.
This project aims to enhance SymPy's GCD computation speed for polynomials in the sparse representation. I will implement Zippel's algorithm from scratch and finalize the integration of the sparse subresultant PRS algorithm. Subsequently, I will develop a benchmarking suite to evaluate all SymPy's GCD algorithms. The resulting data will serve a new heuristic-based dispatcher, ensuring SymPy selects the optimal strategy for any given input.
OpenMRS has historically operated as a single-instance application, creating a "hard ceiling" for scaling and a single point of failure. As global healthcare networks grow, there is an urgent need for High Availability (HA). While foundational work on distributed caching and storage was introduced in version 2.8.x, several critical gaps remain: lack of distributed session management, race conditions during cluster startup, duplicate execution of scheduled tasks, and inconsistent search indexes across nodes. This project aims to complete the "Cluster-Ready" roadmap for OpenMRS 3.x. Drawing inspiration from proven architectures like Confluence Data Center, I will implement a Zero-Footprint, Multi-Replica framework. I hope to do this by Implementing a formal "Local Home vs. Shared Home" split to manage node-specific vs. cluster-wide data. I want to make use of distributed State Introducing Redis and MySQL-backed session management so users remain logged in even if routed to different replicas. Leveraging Infinispan to implement distributed task locking (preventing duplicate background jobs) and a "Cluster Safety" mechanism to detect and mitigate split-brain scenarios. Transitioning Hibernate Search to a shared OpenSearch/Elasticsearch backend to ensure search consistency across the entire cluster. Project Deliverables: A safe startup sequence for containerized environments (Kubernetes/Helm). Configuration-driven support for Redis (Redisson) and JDBC session persistence. A wrapper for the OpenMRS SchedulerService to ensure tasks run on exactly one node. Audit and migration of O3 modules (FHIR2, Webservices.rest) to the distributed cache manager. Application-level wiring for shared full-text search indexes. A robust integration testing framework using Testcontainers to validate cluster behavior in CI/CD.
The project aims to improve longitudinal normative modelling in PCNtoolkit by validating, debugging, and extending velocity-based models to support multiple timepoints per subject. The work will include integrating the updated models into the toolkit’s modular architecture, adding tests and documentation, and developing functionality for predicting individual brain changes over time from multiple past observations.
Zplit is a decentralized, privacy-first group expense tracking application designed to give users full control over their financial data without relying on centralized servers. Unlike traditional apps, Zplit operates using peer-to-peer technologies such as Wi-Fi Direct, Bluetooth, NFC, and QR codes, enabling seamless offline-first collaboration.I will implement Deep Link integration for seamless group invitations, integrate USDC/DAI stablepay settlement for expense splitting, and build interactive data visualizations . All user data will be synced peer-to-peer via Wi-Fi Direct, Bluetooth, NFC, and QR codes, ensuring zero cloud dependency. The final deliverables will include a fully functional Flutter app with Deep Link support, stablepay payment flow, expense visualization dashboard
This project will build and integrate a Python-based client for the buildingSMART Data Dictionary (bSDD) directly into FreeCAD's BIM Workbench. This integration will allow users to dynamically search and apply international classification standards from the cloud, providing context-aware suggestions based on the underlying IFC entity. To ensure a stable and non-disruptive integration, the project will implement a "dual-layer" data model. This approach will securely store the rich, web-fetched bSDD metadata while automatically populating the existing legacy string properties, guaranteeing 100% backward compatibility with FreeCAD's current stable workflows.
Features 1. Per-brush opt-in for scene-level brush settings (“use unified xxx”). 2. Brush tip roundness (currently available in limited brushes). 3. Customizable pressure curves for all pressure-sensitive parameters. 4. Customizable brush toggling and improved toggle display. 5. Improved first-stroke responsiveness across relevant brushes. 6. Pressure handling improvements in anchored mode. Deliverables 1. Tip roundness and tilt support across all relevant brushes. 2. Per-brush “use unified xxx” support. 3. Custom curve controls for all pressure-sensitive parameters, including auto-smooth and hardness. 4. Improved brush toggle UI and behavior. 5. Improved first-stroke responsiveness for relevant brushes. 6. Improved anchored-mode pressure handling. 7. End-user documentation for new features.
The Goal: A 100% x86 Assembly (FASM) news reader that replaces bloated web browsing with high-performance, native headlines. The Strategy: Use FEED struct array allocation (with a +5 buffer) for O(1) efficiency and a Unified Schema Engine to parse RSS. Core Deliverables: a state-driven, 2-pane GUI with "Read/Unread" tracking, a modular backend for http.obj networking and asmXml parsing, and a headless test harness.
This proposal focuses on improving the behavioral evaluation (eval) infrastructure of Gemini CLI to ensure reliable and safe AI tool usage. The current system has significant gaps, including missing eval coverage for ~37.5% of tools, a large number of non-CI-blocking (flaky) tests, and lack of tooling for debugging and contributing to evals. To address this, the proposal introduces a three-part approach: Expand and Stabilize Behavioral Evals Write 15–20 new evals covering uncovered tools and missing behaviors (error recovery, multi-step reasoning, safety, ambiguity handling). Stabilize flaky evals and promote reliable ones to CI-blocking status. Focus on testing tool-call decisions instead of text output for robustness. Enable Contributor Participation via Skills & Subagents Introduce an eval-writer skill to help generate evals. Build subagents like eval_investigator (debugging failures) and quality_analyst (coverage analysis). Make eval development accessible to open-source contributors. Fix Ecosystem Gaps (Process, Tooling, Documentation) Define clear eval review, promotion, and regression-handling processes. Improve logging with readable tool-call traces. Create the Eval Development Kit (EDK) with tools for: Eval inventory & coverage analysis Validation checks Auto-generating evals from real chat logs Add documentation, tutorials, and GitHub automation for easier community contributions. Overall, the goal is to transform evals from a limited internal system into a scalable, contributor-friendly quality framework, enabling the OSS community to actively improve AI behavior, reliability, and performance.
cBioPortal introduced Similarity Maps, a feature that visualizes UMAP/PCA embeddings of cancer samples, allowing researchers to discover hidden patterns across thousands of samples simultaneously. However, the current implementation is a prototype that fetches data directly from a hardcoded S3 URL, bypassing cBioPortal's data pipeline entirely and following no established datahub standards. This project makes Similarity Maps production-ready by building a proper data layer that follows cBioPortal's existing architecture. This includes designing a datahub file format for embeddings, reusing/extending the existing importer to load embedding data into ClickHouse, and exposing REST API endpoints that replace the hardcoded S3 fetch. The frontend will then be updated to consume the new API dynamically. Additionally, enhanced tooltips and improved colouring options will be implemented to strengthen the visualization. Key deliverables include: an approved database schema, a working EmbeddingImporter.java, a validated datahub file format, REST API endpoints, updated frontend integration, and full documentation
Accessing the billions of facts stored in DBpedia's knowledge graph currently requires writing SPARQL queries, putting this incredible resource out of reach for most people. This project tackles that by building a self-correcting Agentic Question Answering system over DBpedia using LangGraph and Qwen3. Rather than attempting one-shot translation like existing Neural SPARQL Machine approaches, which frequently fail when a model hallucinates a property or misresolves an entity, the system grounds the entire reasoning process through a pipeline of deterministic tools including an Entity Linker with a GraphRAG FAISS fallback for ambiguous mentions, a live Ontology Explorer that discovers what predicates actually exist for a given entity, and a Schema Introspector that validates property types before query construction. The core contribution is a conditional self-correction loop where a Validator node diagnoses exactly what went wrong and dynamically routes the agent back to the specific tool needed to fix it, whether that is the entity linker, the predicate explorer, or the query builder, enabling the system to recover from failures instead of collapsing silently. The final pipeline will be rigorously benchmarked against QALD-9-plus and the DB25 dataset from the Text2SPARQL 2025 challenge, providing open, hallucination-free natural language access to the Semantic Web.
In agent-based modeling, the goal is to understand how individual agent behavior agent behavior is influenced by social norms (rules like obligations, prohibitions, and permissions). Using platforms like CORMAS built in Pharo, modelers have to hardcode norms directly into agent behavior, making the system rigid and hard to manage. Using method proxies - a reflective programming technique in Pharo that intercepts method calls at runtime - we propose to implement norms as a separate, modular layer on top of CORMAS with different handlers for obligations, prohibitions, and permissions. This work aims to deliver 1) a CORMAS plugin (cormas-norms) with its tests and documentation, 2) a better UI to manage norms live during simulation, and 3) a real-world use case demo of the plugin.
While working with real-time systems, I observed that Flutter DevTools provides detailed visibility for HTTP requests but lacks support for persistent protocols like WebSockets. Once a connection is established, developers have little to no insight into message flow, latency, or connection lifecycle, making debugging significantly harder. This project aims to address that gap by extending the Dart SDK (dart:io, dart:developer, and the VM Service) to capture WebSocket frame-level and connection-level data. This data will then be integrated into the DevTools Network panel, following the existing HTTP profiling model to ensure consistency and minimal overhead. The implementation will include WebSocket instrumentation in dart:io, exposure of profiling data via the VM Service, and UI integration in DevTools to display messages, sizes, latency, and lifecycle events. If time permits, the same architecture will be extended to support gRPC traffic. By the end of the project, developers will be able to inspect WebSocket communication in DevTools with the same clarity and usability as HTTP, significantly improving debugging for real-time applications.
CrocoLakeTools currently downloads ocean datasets from static sources, either a fixed URL or a fixed file list. This works for stable snapshots like GLODAP, but not for live ERDDAP servers like the IOOS Glider DAC, which hosts hundreds of delayed-mode glider deployment datasets that grow and change over time. This project builds an incremental sync layer targeting the IOOS Glider DAC. The implementation follows a three-layer architecture discussed with the mentor: a CLI script for user interaction, a dataset-specific downloader (DownloaderIOOSGliders) that handles ERDDAP query logic and URL construction using erddapy, and the base Downloader class that provides shared tools used by all downloaders in the package. The sync tool queries the server, compares server-side timestamps against local files, and downloads only what is new or updated. Files are stored exactly as served by ERDDAP with no schema conversion. Deliverables: (1) download_parallel() added to the base Downloader class, (2) DownloaderIOOS base class wrapping erddapy, (3) DownloaderIOOSGliders with incremental sync logic, (4) download_ioos_gliders.py CLI script, (5) unit and integration tests, (6) animal telemetry subclass as a stretch goal.