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.
skpro's probabilistic regressors have limited online/streaming support: only 3 of 20+ regressors implement update(), few meta-strategies exist, and there is no model persistence. This project adds: 1) native _update() for regressors with incremental APIs (NGBoostRegressor, BayesianLinearRegressor, BaggingRegressor) 2) composable meta-strategies (OnlineSlidingWindow, OnlineBatchMixture, OnlineExponentialForgetting) usable with any regressor 3) update() propagation through Pipeline and TransformedTargetRegressor 4) save()/load() ported from sktime's serialization pattern
Music Blocks currently relies on a manual and irregular release process, which leads to deployment delays, higher risk of human error, and limited visibility into application health. This project aims to modernize the release workflow by introducing a fully automated, reliable, and auditable CI/CD pipeline. The solution will involve designing and implementing automated deployment workflows integrated with existing CI, enabling seamless releases from the main branch. Key improvements include semantic versioning and automated changelog generation, Docker-based builds published to GitHub Container Registry, and a multi-environment setup with staging and production. The pipeline will incorporate preview deployments, approval gates, and pre/post-deployment validation to ensure safe and consistent releases. Additionally, rollback mechanisms, monitoring, and deployment notifications will be added to improve reliability and observability. The final deliverables will include a complete CI/CD pipeline, containerized deployment setup, automated versioning and changelog system, staging and production environments with deployment workflows, rollback and validation mechanisms, monitoring and alerting integration, and comprehensive documentation with runbooks and troubleshooting guides.
Over the summer, I'll be shipping Windmill (a cheap, auction-based DEX), Karma (an oracle run entirely by its users), OrbOracle (custom on-chain price feeds), and MiniChain (a hands-on Python curriculum). My goal is to make decentralized trading significantly cheaper and safer, while using the new MiniChain platform to actually teach beginners how blockchains work.
R's standard file reading functions must ingest data into memory before any filtering can occur, creating a hard memory ceiling for large datasets. AWK evaluates records one line at a time, filtering data before it ever enters R's memory space. The awkreader package bridges these two worlds, letting R users express filter conditions in familiar R syntax while AWK handles the heavy lifting at the shell level. The existing codebase is ~80% complete for Mac/Unix. This project completes and delivers the full production-ready CRAN package by: (1) completing and verifying the full translation engine: mapping R filter expressions including comparisons, logical operators, %in%, grepl(), and is.na() to correct AWK syntax across all platforms. (2) auditing and restoring Mac/Unix correctness. (3) achieving full Windows/PC compatibility via robust shell quoting and Rtools detection. (4) formalizing the package with roxygen2 docs, a cross-platform CI test harness with regression locking, and CRAN submission, enabling R users to filter datasets on standard hardware without memory constraints.
Frameworks like PennyLane and Qiskit handle circuit construction and simulation well but provide almost no tools for measuring the quantum resources a circuit uses. No unified library exists to assess profiling entanglement, magic, or Bell nonlocality. I propose a PennyLane-based library computing four resource classes through a single resource_profile() API: entanglement (Meyer–Wallach, Von Neumann entropy, concurrence), magic (Stabilizer Rényi Entropy), mana (discrete Wigner negativity for qudits), and Bell nonlocality (CHSH values). Since PennyLane QNodes are differentiable, the measures inherit gradient access for tracking resource shifts during training. I also propose benchmarking across QAOA for MaxCut, Quantum Phase Estimation, VQE for molecular ground states (H₂, LiH), and quantum autoencoders for BSM event detection following Duffy et al. (arXiv:2407.07961). The study would record resource trajectories per epoch and test whether the resource decrease Duffy et al. observed generalizes, via Spearman correlations and Mann–Kendall trend tests. This project grows out of my prior work. My Quantum Encoding Atlas library (DOI: 10.5281/zenodo.18780936) benchmarks 16 encodings across PennyLane, Qiskit, and Cirq, and my 12 QMLHEP15 evaluation tasks span quantum circuits, GNNs, equivariant QNNs, RL for PQC optimization, and contrastive learning. Running those benchmarks I identified SRE as a missing diagnostic, which inspired me towards this project. Deliverables: 1. Python package on PyPI with entanglement, magic, mana, and nonlocality modules. 2. Circuit profiler for epoch-level resource tracking. 3. Benchmarking dataset for all four algorithms. 4. Resource–performance correlation analysis. 5. API docs and Jupyter notebook tutorials. 6. Two blog posts per ML4SCI requirements. Stretch: tensor network SRE approximations beyond 10 qubits and integration with Knipfer et al.'s agent-based VQC design (arXiv:2602.19387).
The current MoFA architecture tightly couples agents to a single inference backend (e.g., OpenAI, Ollama), making switching providers, handling failures, or optimizing cost and latency difficult without modifying agent code. This project introduces the Cognitive Compute Mesh (CCM): a distributed inference layer implemented as a new mofa-gateway crate that transparently sits behind the LLMCapability interface. Instead of acting as a central gateway, CCM enables a mesh architecture, where every node (local, cloud, or edge) participates in both computation and routing. The system is built around three core components: - A typed Inference Request Protocol (IRP) that standardizes communication across all providers - An intelligent routing layer that dynamically selects backends based on latency, cost, capability, and health - A production-grade RAG pipeline with hybrid retrieval (dense + BM25), reranking, and caching CCM ensures that agents become backend-agnostic, enabling seamless failover, cost optimization, and hybrid local-cloud execution without code changes. Deliverables: - mofa-gateway crate implementing LLMPlugin - Backend SDK for integrating new inference providers - Support for OpenAI, Anthropic, Ollama, and OminiX-MLX - Distributed routing with circuit breakers and health tracking - Full RAG pipeline with vector storage support - Documentation, benchmarks, and demo showing backend-agnostic agents This project aims to establish a protocol-level abstraction for AI inference, similar to how HTTP abstracted networking enabling “write once, run anywhere” for AI agents.
Apache Fineract’s current command processing system relies on a centralized service and untyped JSON payloads, which limits type safety and causes errors to surface only at runtime. In a financial system, such issues can disrupt critical operations and reduce reliability. This project proposes to migrate selected modules to the new CQRS-based fineract-command architecture, which introduces typed commands, structured handler dispatch, and extensible processing hooks. The migration will cover the full request lifecycle—from REST APIs to business logic—while strictly preserving backward compatibility through unchanged integration tests. Key deliverables include migrating open and unassigned modules to the new architecture, introducing type-safe DTOs with validation, replacing legacy JAX-RS endpoints with Spring Web MVC controllers, integrating the CommandPipeline with typed handlers, removing obsolete legacy components, and producing a comprehensive migration guide to enable future contributions.
This project builds a Gemini CLI extension that solves MCP's context bloat problem for Rocket.Chat developers. Current MCP servers expose an entire platform's API surface, meaning every agent session wastes tokens on hundreds of tool definitions the project will never use. The Minimal MCP Server Generator lets developers describe their use case in plain English and produces a production-ready MCP server covering only the endpoints they actually need. The generator goes beyond raw API wrappers by composing multi-step workflow tools: declarative step graphs that chain API calls, AI reasoning, conditional branching, and data transforms into single high-level operations. It supports two compilation targets: a standalone webhook + REST server that runs anywhere, and an Apps-Engine bridged mode for realtime event interception. The key deliverables include: a Gemini CLI extension with endpoint discovery, schema lookup, and project generation tools; a six-pass workflow validation pipeline that catches and self-corrects LLM mistakes before codegen; additive tool generation that adds new tools to existing servers without overwriting; protocol-level test generation via MCP Inspector; runtime hardening with endpoint allow-lists; and a PlatformProvider abstraction with a Mattermost dry-run proving the generator's portability beyond Rocket.Chat. This approach reduces token costs, fits within free-tier limits, and makes MCP-based Rocket.Chat development accessible to any workspace regardless of plan.
Iteratively reshaping the cells of a 3D mesh to improve quality for simulations like finite element analysis — is computationally expensive: large meshes can take hours on a single CPU core. CGAL provides a widely used implementation, and GSoC 2025 built the infrastructure to run it in parallel, achieving a ~28% speedup on large meshes. Two problems remained: threads spent most of their time waiting to access the mesh rather than doing useful work, and the parallel version produced lower mesh quality than the sequential one. The 2025 code also never made it into the official CGAL repository. This project fixes both problems and introduces a new scheduling strategy: instead of rigidly applying all splits, then all collapses, then all flips, then all smooths, a unified priority queue ranks every candidate operation by its estimated quality improvement and always applies the most beneficial one first. This has the potential to reach the same final quality in fewer operations and has not previously been applied to tetrahedral remeshing.
My proposal is to develop a scalable computational pipeline to construct, annotate, and visualise Sequence Similarity Networks (SSNs) for a representative subset of approximately 10 million MGnify proteins. The pipeline will take FASTA files as input and utilise MMseqs2 to efficiently compute all-against-all pairwise sequence similarities. It will then use the Python library NetworkX to construct the mathematical graphs, integrating biological metadata, such as the biome-of-origin, directly into the node attributes to enable contextual environmental exploration. To ensure scalability and avoid memory bottlenecks, the pipeline will leverage NetworkX's backend dispatching architecture to route computationally heavy operations to high-performance GPU libraries like cuGraph. Finally, the graph data will be exported into simple tabular formats compatible with large-scale visualisation platforms like Cytoscape and Cosmograph. The deliverables of this project will include the core Python/Bash SSN generation pipeline, a MGnify metadata annotator, a graph exporter utility, a fully rendered 10-million node reference dataset, and comprehensive documentation alongside an integration test suite.
PostgreSQL’s `generate_series()` is powerful for reports and time‑series work, but Django currently lacks a first‑class `ORM API` for it. I will add native support in `django.contrib.postgres` by extending the `ORM` to treat set‑returning functions as table sources using `set_returning`, a new `Relation` abstraction, and `RelationCol` references, implemented via `CROSS JOIN LATERAL`. The result will let developers use `.annotate()`, `.filter()`, `.order_by()`, `.count()`, and `.aggregate()` with generated series without raw SQL. Deliverables include the API surface, type inference for `date/time` series, and a robust test suite covering edge cases, joins, and large sequences.
Improving the testing system of the Kiwix Android app to make tests more stable, faster, and reliable. This includes fixing flaky tests, improving CI/CD performance, and ensuring testing reflects real-world usage conditions.
Optimize multi-scale Gabor filter bank algorithms on GPUs for detecting and excising 5G / satellite communication interference from deep sky data.
The PyArrow project currently faces performance bottlenecks when used in astronomy computational work on massive datasets, such as the HATS catalog light curves. Specifically, the Apache Arrow C++ and PyArrow implementations struggle with parsing multi-level nested Parquet files due to underutilized multi-threading, lack the ability to selectively load specific fields from deeply nested structures, and feature compute kernels that do not support nested datatypes. This project aims to resolve these core issues to drastically improve load times and resource efficiency for the astronomy community.
Global financial entities, clearinghouses, and settlement networks require absolute precision in market scheduling to maintain operational integrity, compliance, and international goodwill. Currently, the open-source ecosystem forces developers and financial institutions to rely on expensive, proprietary APIs for this critical data. This project democratizes global market schedules by significantly expanding Holiday's financial coverage, implementing native, offline calendars for 15-17 new global exchanges across the Americas, EMEA, and APAC regions. Every newly integrated market will be mapped to standard ISO 10383 Market Identifier Codes (MIC), strictly researched for deep historical accuracy, and equipped with native localization (L10N) support.
-fbounds-safety is a C language extension designed to prevent out-of-bounds memory accesses. Currently, upstream Clang provides partial support for some annotations such as counted_by. The proposal aims to extend the scope of the currently supported annotations and upstream missing ones.
Cellfinder currently expects full 3D whole-brain volumes with both signal and background channels, so brain slices (2.5D) and single-channel acquisitions are not first-class citizens. The codebase also mixes axis conventions, which makes dimensionality changes error-prone. A recent data-loading refactor introduces explicit axis tracking and a new class hierarchy for cube generation and augmentation; the 2D/2.5D and single-channel work proposed here will build on that foundation. The core deliverables are to standardise axis semantics as the foundation, add a 2D detection path for brain slices and refactor classification to support both 2D and 3D inputs, and make the background channel optional across the main API and classification pipeline.
Milvus currently lacks a Debezium source connector, meaning data can flow into Milvus (via sink connectors) but not out of it into the broader data ecosystem. This critical gap forces users into manual workarounds for data replication, auditing, and prevents the creation of hybrid pipelines that join vector search results with relational data. The plan is to implement a Hybrid strategy focused exclusively on the future-proof Milvus 2.6+ StreamingNode architecture. This approach will leverage two separate sources to guarantee a complete and ordered change stream: Woodpecker Streaming Service (WAL): Used as the only source for all Data Manipulation Language (DML) events (inserts and deletes). Etcd Watch: Used as the cleanest source for all Data Definition Language (DDL) events (schema changes), which simplifies parsing and aligns with Debezium's schema history mechanism.
SOFIE generates standalone C++ inference code from trained neural networks, letting HEP frameworks run ML models without heavy external dependencies. Its integration with the alpaka library enables portable GPU inference that works across NVIDIA, AMD and CPU backends from a single codebase. The current GPU path covers basic operations but lacks support for several key operators needed to run full neural networks on GPU. This project implements the missing GPU kernels and extends convolution to handle batched inputs, so complete CNN architectures can run end-to-end on GPU through SOFIE. The final goal is a ResNet-style model running fully on the alpaka GPU backend and validated against the CPU reference.
This project develops a vendor-agnostic GPU-accelerated SONAR simulation plugin for Gazebo by migrating the current CUDA-centric approach to a wgpu-based compute pipeline. Current existing physics-based underwater sonar plugin rely on CUDA for speed, which limits users to NVIDIA GPUs and complicates deployment in mixed hardware environments (AMD/Intel/Apple Silicon GPUs, and future-proofed stacks). Recent advances in cross-platform GPU APIs and the Rust wgpu ecosystem make it feasible to run high-throughput compute workloads across Vulkan / DirectX / Metal backends via a unified abstraction to utilize GPGPU capabilities. This project uses that foundation to implement sonar image synthesis on the GPU without vendor lock-in, while keeping Gazebo/ROS 2 integration clean and upstream-friendly.
This project extends AIDRIN’s data ingestion layer beyond CSV and basic tabular formats to better match real scientific workflows. I will (1) audit and harden the existing HDF5 path, (2) add new readers for Zarr and ROOT (via uproot), and (3) introduce a simple custom ingestion interface that normalizes user‑supplied data sources into a pandas DataFrame and metadata dictionary before AIDRIN’s metrics run. The work includes dataset/TTree selection UX, chunk‑aware reading for large N‑dimensional arrays, metadata extraction for FAIR-related metrics, and a full set of tests and documentation. By the end of the project, researchers will be able to use AIDRIN directly on common scientific formats and plug in their own loaders without modifying the core codebase.
fsck.erofs currently relies on a strictly synchronous execution path for image unpacking and verification. This design causes the main thread to become heavily bottlenecked by synchronous I/O during file extraction, which subsequently blocks the CPU-intensive decompression phase. As EROFS images scale in size, this sequential pipeline creates a significant performance barrier across container environments, embedded systems, and developer workflows. This project resolves the synchronous I/O bottleneck by introducing a multi-threaded decompression pipeline built on a producer-consumer architecture. A background workqueue will enable the main thread to handle directory walks and queue compressed blocks, while a dedicated worker thread pool processes the decompression payloads. To eliminate heavy scheduling overhead and lock contention, the project introduces dynamic pcluster batching, which groups sequential blocks into a single work unit and scales the batch size based on the specific compression algorithm in use. Additionally, the extraction process will be further accelerated by a thread-safe, LRU-bounded metadata cache protected by read-write semaphores to prevent redundant I/O and strictly bound memory usage. The deliverables for this project include a scalable, multi-threaded extraction pipeline for fsck.erofs integrated with erofs_workqueue , alongside dynamic pcluster batching heuristics optimized for LZ4, LZMA, DEFLATE, and Zstandard to minimize futex overhead. Additionally, the project will provide a thread-safe, LRU-bounded metadata cache designed to significantly reduce redundant I/O , and the implementation will be validated through comprehensive regression tests, edge-case validations for corrupted images, and Flamegraph-backed performance benchmarks.
MNE-Python provides powerful 3D PyVista brain viewers and 2D Matplotlib sensor plots, but these tools currently operate in isolation. This project bridges that gap by extending the mne.viz.ui_events registry to allow bidirectional interactivity between source-space and sensor-space visualizations. I will implement a decoupled event system where selecting a 2D time-point updates the 3D topography, and picking a 3D vertex or ROI (Region of Interest) instantly generates the corresponding 2D evoked time-course. This solves a major UX bottleneck for researchers validating inverse solutions and interpreting neural models. Key Deliverables: - A bidirectional event-callback architecture integrated into mne.viz. - Synchronized UI updates for mne.viz.Brain and mne.Evoked.plot_* (topomaps and joint plots). - A prototype "Interactive Dipole" tool for real-time forward modeling (Xfit replacement). - Comprehensive pytest fixtures for the new event classes and a sphinx-gallery tutorial demonstrating the interactive workflow.
Kotlin is one of the most widely used languages in modern software development, but there is no structured, global picture of how it is actually being taught. Students graduate without knowing coroutines. Courses skip Jetpack Compose. Academic syllabi lag years behind what the industry expects. This project exists to measure that gap and help close it. I will collect and analyze data from 80+ university curricula across 6 regions, online course platforms including Udemy, Coursera, and JetBrains Academy, surveys of 150+ students, educators, and developers, and 500+ public GitHub repositories comparing educational and real-world Kotlin code. Using Python, SQL, and Tableau, I will identify where the gaps are largest, what is driving them, and what can be done about it. The deliverables are: a curated open dataset of Kotlin educational resources, an interactive dashboard for the community to explore trends by region and topic, and a comprehensive "Kotlin in Education" report with concrete recommendations for the Kotlin Foundation and educators worldwide.