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.
Ultimate Alarm Clock III (UAC) aims to evolve into a production-ready, cross-platform mobile application that delivers intelligent, condition-based alarm functionality. The core problem addressed is the limitation of traditional alarms, which lack contextual awareness and flexibility in triggering based on real-world conditions such as location, calendar events, or user activity. To solve this, the project will enhance UAC with advanced conditional logic and deep integrations, including Google Calendar synchronization, Google Assistant voice controls, and customizable task lists linked to alarms. Additionally, the system will improve reliability through enhanced alarm history logging and debugging tools, while enabling seamless synchronization with a companion app. Infrastructure improvements such as CI/CD pipelines, automated testing, and Play Store deployment workflows will ensure scalability and maintainability. A stretch goal includes developing an iOS version with native background execution capabilities to ensure consistent alarm behavior across platforms. The key deliverables include: Implementation of core features such as calendar-based alarms, voice interaction, shared alarms, and task lists Advanced developer diagnostics via alarm history and logging systems Companion app synchronization with real-time data consistency A robust CI/CD pipeline for automated testing and deployment (Stretch) iOS support with native integrations for reliable background execution Together, these deliverables will transform UAC into a scalable, production-grade application with intelligent, context-aware alarm capabilities and a strong foundation for future development.
This project enhances NiMARE’s performance and developer accessibility through a dual-phase optimization strategy. The first phase modernizes the contributor onboarding framework by updating development environment documentation and Git workflows to reflect current best practices, ensuring a lower barrier to entry for new developers. The core technical phase implements a fixed-width confidence interval stopping rule for ALE and MKDA workflows. By integrating an adaptive framework based on the Wilson Score Interval, the system dynamically prunes voxels as p-value convergence reaches statistical decisiveness. This approach significantly reduces computational overhead and execution time while maintaining Type I error control. Deliverables include an extensive benchmarking against standard 10,000-iteration runs, and—progress permitting—the expansion of NiMARE’s methodology through Signed Difference Mapping (SDM) and Publication Bias Diagnostics (Fail-safe N).
This project aims to transform the CircuitVerse mobile application into a fully functional, stable, and production-ready platform that matches the capabilities of its web counterpart. Currently, gaps in core features, inconsistent user experience, and technical instability limit the app’s effectiveness as a learning tool. By addressing these challenges, the project focuses on implementing missing web features, stabilizing authentication, and restoring key modules such as the interactive book to ensure a seamless and engaging learning experience on mobile devices. In addition to feature parity, the project emphasizes improving performance, fixing critical bugs, and enhancing UI consistency and accessibility. A scalable and maintainable architecture will be established to support long-term growth and easier development. Special attention will also be given to localization and multilingual support, making the platform more inclusive and accessible to a global audience. Overall, this initiative is important for CircuitVerse as it enables broader reach, improves usability for mobile users, and ensures that students worldwide can reliably access interactive digital circuit learning resources anytime, anywhere.
MetaCall's runtime introspection (metacall_inspect) requires loaded loaders and a live environment, leaving IDE tooling, CI pipelines, and Function Mesh with no pre-runtime project intelligence. This proposal builds metacall-ast - a standalone Rust static analyzer that uses Tree-sitter incremental parsing to extract symbols and cross-language dependencies from Python, JavaScript, TypeScript, C/C++, and Rust source files, emitting JSON structurally compatible with metacall_inspect (keys: funcs, classes, objects). The tool uses petgraph for in-memory graph construction, applies Tarjan's SCC algorithm to identify independently deployable Function Mesh units, and exposes a stable C ABI (mc_ast.h) for embedding in MetaCall core. An optional Dgraph sink enables persistent Code Knowledge Graph snapshots. Deliverables: core Rust library + CLI, language packs for 5 languages, inspect-parity JSON output, C ABI bridge, Dgraph sink, and a stretch intra-procedural dataflow (def-use chains), with full CI on Linux/macOS/Windows.
The project aims to extend API Dash with Git-backed collections, a visual workflow builder, and a collection dashboard. This will enable developers to version and share API collections, design and execute multi-step API flows, and monitor API health and performance within a single unified tool. Problem Being Solved: API Dash currently stores requests in a flat local structure without version control or collaboration support. The existing load-all/manual-save model limits reliable syncing, introduces risk of data loss, and prevents building higher-level features like analytics and workflows. Additionally, users lack visibility into API performance and have no structured way to define multi-step API interactions. Proposed Solution: 1. A refactored persistence layer using request-level autosave (Hive LazyBox) for reliable and granular data storage. 2. A GitHub integration layer to enable version control, sharing, and collaboration on collections. 3. A visual workflow builder with a node-based interface to define and execute multi-step API flows. 4. An execution engine to handle request chaining, conditions, and shared data flow between steps. 5. A dashboard system to aggregate and visualize API and workflow performance metrics. Key Deliverables: 1. Request-level autosave system replacing the current bulk-save model. 2. Git support for collections (connect, import/export, push/pull, commit history, rollback). 3. Visual workflow builder with execution support, run history, and DashBot-assisted workflow generation from natural-language prompts. 4. Collection and workflow dashboards showing success rates, failures, and latency signals. 5. Production-ready documentation, testing, and UX polish for real-world usage.
The Flexible Network Tester (Flent) is an industry-standard tool for evaluating Bufferbloat and network performance. However, benchmarking simulated networks in ns-3 currently requires researchers to rely on external, error-prone parsing scripts to translate simulator events into Flent-compatible data. This project solves this disconnect by natively integrating the Flent Application API into the ns-3 mainline. The proposed solution involves modernizing a legacy C++ wrapper, eliminating artificial queue constraints used in prior proof-of-concepts, and refining the linear interpolation logic to accurately translate discrete ns-3 trace callbacks into strict periodic data points. A critical phase of the project involves scientific validation. comparing the simulated ns-3 outputs against real-world Linux hardware benchmarks (using tc and ss) to guarantee mathematical and statistical accuracy. Deliverables: 1) A robust, memory-safe FlentHelper C++ API that allows users to seamlessly configure tests and directly output visualization-ready .flent JSON files. 2) A scientific validation report proving the parity between the simulated network metrics and physical Linux network namespaces. 3) Expanded support for complex multi-flow Bufferbloat tests (including RRUL, Best Effort, and VoIP). 4) Comprehensive user documentation and automated example scripts merged into the ns-3-dev mainline.
We want to implement an algorithm to compute from a surface mesh representation a basis for 1-homotopy and 1-homology groups represented by polylines and with minimal combined length. To do this, we will first extract a minimal set of loops that are independent in the homotopy group and pass through a common vertex; this set is a basis for the homotopy group. We will furthermore minimize the cumulated length of those loops. Then, by iterating this process on all vertices, we will compute a basis for the homology group.
Point cloud data is widely used in domains such as reverse engineering, medical imaging, and cultural heritage preservation. However, many applications (e.g., simulation via FEM) require high-quality triangle meshes derived from point clouds. This project aims to implement the algorithm proposed in "Lipschütz, H., Reitebuch, U., Polthier, K., & Skrodzki, M. (2023). Feature-aware manifold meshing and remeshing of point clouds and polyhedral surfaces with guaranteed smallest edge length" and integrate it into the CGAL library. The method generates high-quality, isotropic meshes with near-uniform edge lengths and manifold guarantees, addressing limitations in existing reconstruction approaches.
Miri finds undefined behavior but can't explain why, its only debug aid is thousands of lines of interpreter logs. The original Priroda step debugger bitrotted from tight coupling and no CI. This project rebuilds Priroda with a three-tier architecture: a Miri integration layer, a stable core debugger API (step, breakpoints, locals, allocations, threads), and a DAP server giving any modern editor step-debugging support. It lives inside the Miri repo with CI and scripted tests to prevent future bitrot.
This proposal is for the ML4SCI GSoC 2026 project “Brain-to-Brain Decoder – Validating Neural Synchrony Patterns in Human Conversation.” The project builds on the 2025 NeuroDyads pilot, which reported 94% accuracy on decoding conversational roles and participant gender with CEBRA on 8 dyads, and extends that work to an expanded dataset of 40+ dyads. My goal is to build a reproducible, leakage-aware analysis pipeline for time-locked dyadic EEG that is not only effective, but scientifically trustworthy. I will focus on four concrete tasks from the project page: implementing stratified cross-validation for dyadic EEG, computing cross-entropy distance metrics between embedding distributions, generating learning curves for stable dyad decoding, and mapping embedding structure back to localization and frequency-band features that contribute to neurotype classification. The final deliverables will include a modular preprocessing and evaluation pipeline, baseline and control experiments, quantitative embedding-comparison tools, sample-size/stability analyses, and interpretable region- and band-level summaries for clinical vs. neurotypical comparison.
This project addresses the challenge of limited and imbalanced datasets in coronary artery calcium (CAC) analysis, particularly for rare high-risk cases such as high Agatston scores. Existing augmentation methods rely on heuristic or purely data-driven approaches that lack physiological realism. We propose a physics-informed generative framework for synthetic CAC data creation. Building on a validated atlas-based registration pipeline, the project models plaque formation as a stochastic process governed by latent hemodynamic factors. A reduced-order physics-informed neural network (PINN) will estimate endothelial shear stress (ESS), which will guide a stochastic differential equation (SDE)-based model to simulate realistic plaque growth patterns. The system will generate anatomically and physiologically plausible calcium distributions, with controllable parameters such as Agatston score, vessel territory, and lesion phenotype. Deliverables include a modular Python-based generation pipeline, a synthetic dataset of 300–500 scans covering long-tail cases, and a comprehensive evaluation using statistical, structural, and expert-based validation metrics. This work shifts CAC data augmentation from heuristic placement toward physics-driven simulation, enabling more robust and generalisable machine learning models for medical imaging.
Replacing hand-written radosgw-admin documentation with a programmatic pipeline using CLI11 as the single source of truth. Auto-generates --help, man page, and admin guide from C++ definitions.
Many Fossology users struggle to reuse old license decisions because they have to find the right files themselves. This project makes the Reuser agent smarter by adding an 'Auto-Suggest' feature that automatically finds and ranks the best old versions to use. It also adds a visual 'Diff View' dashboard so users can easily compare files side-by-side. These changes, along with database performance fixes, will make license clearing in Fossology much faster, clearer, and more automated for the users.
PEcAn's North American carbon reanalysis assimilates satellite and ground observations into SIPNET at 1km resolution, but has never been directly compared to TRENDY or CMIP model ensembles. This project builds a reproducible Python pipeline using ILAMB to score PEcAn alongside all available TRENDY and CMIP models on the same observational benchmarks across five to six variables (AGB, LAI, soil moisture, soil carbon, GPP, NEE). Deliverables include ILAMB scorecards, a reusable ensemble calibration module comparing within-model vs across-model uncertainty, regional diagnostic notebooks, and updated temporal benchmarks contributed back to ILAMB.
circt-bmc can already prove when an assertion is falsifiable, but it does not yet produce the counterexample trace format hardware developers rely on for debugging. Today, users get a SAT/UNSAT result without a practical cycle-by-cycle waveform showing how the design reached failure. This project adds that missing debugging path. I will preserve meaningful signal identities before lowering, track the corresponding solver expressions across BMC timesteps, and evaluate those expressions against the first satisfying Z3 model. The implementation is intentionally staged: first a readable text counterexample for the failing prefix, then VCD waveform generation from the same trace data. The focus is the first-failure prefix (cycle 0 to the violating step), which delivers high user value with low integration risk and clean upstreamability. Deliverables: 1. Signal tracking and naming pipeline for user-relevant values (ports, externalized registers, selected internals where remapping is reliable). 2. A BMC trace runtime component that records per-step solver ASTs and supports model-driven trace emission. 3. Midterm milestone: first-failure text counterexample dump. 4. Final milestone: VCD waveform output for the same counterexample path, exposed through circt-bmc CLI flags. 5. Upstream-quality tests and documentation (IR-level + end-to-end regressions, including failing and no-violation cases).
This project aims to transform how analysts interact with threat intelligence data in IntelOwl by introducing a conversational AI interface. Currently, analysts must manually navigate dashboards, query APIs, and correlate results across different jobs and investigations. To solve this, I will integrate a privacy-preserving, self-hosted LLM chatbot using Ollama and a LangChain ReAct agent. The agent will be equipped with custom tools to query IntelOwl's internal REST API using natural language. Key deliverables include: 1) A new Django chatbot app handling WebSocket connections via Django Channels for real-time token streaming. 2) Ollama Docker integration with CPU/GPU auto-detection. 3) A native React chat component embedded in the existing frontend. 4) Custom LLM tools for triggering analyses and searching data models. 5) Comprehensive test coverage and detailed documentation for users and future maintainers.
To build a DJ application with two decks in Pharo, I will make use of three libraries: Phausto for audio file playback (at variable speed), equalization, and filtering. Spec for building a browser to visualize audio files in a folder together with their metadata, and to organize these files into playlists. Bloc for the visualization of audio waveforms and the rendering of UI widgets to control playback speed, pitch, levels, the equalizer, and filter cutoff and resonance. As a first step, Phausto will be used to load and simultaneously play two audio files, mixing them via the Phausto API. Once the audio engine is in place, a Spec application will be built to browse audio files and load them into either of the two decks. With the file browser complete, a conventional user interface will be added to control the mix between the two tracks and their equalization. The Phausto standard library will then be used to add a delay effect per deck. With the DJ application running, final polish can be applied in the form of BPM detection and track quantization, which requires implementing peak detection for audio files within Pharo. Deliverables: The Spec application with audio file browsing and audio playback will be delivered before the first evaluation. The audio visualization and UI built with Bloc will be delivered halfway between the first and final evaluations. Extra features (BPM detection and quantization) will be added and tested before the final evaluation.
The current OpenKruise Rollout implementation for Deployment progressive delivery mutates the updateStrategy to Recreate, creating a dangerous risk window: if the Deployment is not properly paused during rollout disable, removal, or controller crash, all pods could be simultaneously recreated, causing a service outage (ref openkruise/rollouts#305). This project implements a safer alternative by keeping the Deployment strategy as RollingUpdate and leveraging minReadySeconds and progressDeadlineSeconds to control the delivery pace. Updated pods remain in a "Ready but not Available" state, giving the Rollout controller precise batch-level control without the catastrophic failure mode of the current approach. Deliverables: 1. A new minReadySeconds-based progressive delivery implementation for Deployment in OpenKruise Rollout 2. End-to-end test suite covering normal rollout, rollback, controller crash recovery, and edge cases 3. Documentation for the new deployment strategy mode
RUXAILAB supports five study types but lacks focus group functionality. This project adds FOCUS_GROUP as a new study type under the Inquiry category, delivering structured session configuration with discussion guides, real-time multi-participant data capture via Firebase RTDB, manual thematic structuring, and NLP-assisted analysis through cost-tiered Python Cloud Functions. Core deliverables include the full focus group lifecycle - create, configure, run, capture, persist, and analyze - following the established Heuristic module architecture. Stretch goals include a LiveKit SFU integration for reliable video, sentiment-analysis-api integration for audio sessions, and a PDF report generator.
This project migrates CircuitVerse's hardware synthesis pipeline from a legacy server backend to a fully offline, zero-latency WebAssembly execution environment. By integrating the YoWASP engine within a dedicated Web Worker inside the Tauri desktop app, the project delivers client-side Verilog synthesis with a reactive Pinia state architecture, custom topological circuit layout, a full Vitest parity test suite, and contributor documentation, all without affecting existing web users.
This project extends Apache Airavata to support interactive development sessions on HPC clusters by integrating linkspan as a managed on-node agent. It addresses the gap by bringing interactive sessions under Airavata's existing framework for authentication, resource management, experiment tracking, and data movement. The proposed solution adds an Airavata mode to CS-Bridge in which users authenticate through Keycloak, discover resources through Airavata, and launch linkspan sessions as Airavata-managed jobs. Each session will be tracked as a first-class Airavata experiment with lifecycle state and recoverable metadata. On the backend, linkspan will be registered as an Airavata application with per-resource deployment descriptors, server-side workflow YAML generation, and an orchestration path for environment setup, job submission, and monitoring. The main deliverables are linkspan application registration in Airavata, interactive-session experiment tracking, new REST endpoints for session management, two minimal linkspan workflow actions for status and VFS reporting, Airavata mode in CS-Bridge, overlay-aware data movement integration, and an end-to-end tested and documented demonstration of the complete workflow.
Lumen handles tabular data through DuckDB but cannot work with N-dimensional scientific formats like NetCDF, Zarr, and HDF5. This project brings first-class xarray support to Lumen by building on my already-merged XArraySQLSource (PR #1741), wiring it into Lumen AI for natural language queries over scientific data, and extending the Pipeline to natively handle xarray.Dataset via narwhals. After this integration, a climate scientist can run "lumen-ai serve data.nc" and ask "show temperature anomalies over Europe" - the AI generates DataFusion SQL, queries the data, and renders the visualisation. Deliverables: 1. Source enhancements: cloud data support (S3/GCS/HTTP via fsspec), multi-file datasets, Dask chunked lazy loading 2. AI integration: coordinate-aware context builder, Jinja2 prompt templates, scientific analysis subclasses 3. Pipeline support: Narwhal compatibility layer, native xarray.Dataset operations without flattening 4. Documentation: user guide, API reference, 3 tutorials, 5 gallery examples Xarray has 16M+ monthly downloads, but no framework connects it to an AI-queryable dashboard today. This project fills that gap.
While Open Library excels at patron aquisition, it struggles with retaining the patrons- this happens due to a break in flow as post sign up patrons are met with an empty dashboard and lack of personalization. Without clear guidance, patrons struggle to find 'What to do next?' and drop off without engaging with the library or features such as reading lists and social connections. This project aims to bridge that very gap between 15 million patrons and 40 million works by introducing a progressive onboarding flow and a highly personalized dashboard for its patrons. By capturing user preference on sign up, we can personalize their dashboard ridding of the empty experience and providing clear Next steps, along with redesign of the dashboard to emphasize the high value features. Deliverables: Progressive Onboarding Flow (A 3-part form that captures and stores broad patron taste, specific book taste and yearly reading goal), Personalized Dashboard (Overhaul of the present 'My Books' page to priortize high-value features and addition of the 'Next reads' system), and the Recommendation Engine that powers the 'Next Reads' components using existing solr infrastructure.
Dear Sir, I hope you are doing well. My name is Tianyou Liu, and I am writing to submit my GSoC 2026 proposal for Mogan STEM: “Julia Plugin with Virtual Environment Support.” In the proposal, I describe an implementation plan to enable Julia-powered, reproducible computing directly inside Mogan. The key technical components include: Mogan-side Julia plugin to identify and extract Julia code sections and provide an in-editor execution workflow. A persistent local Julia kernel process to execute code on demand and maintain session state across runs. A lightweight IPC layer between Mogan and the kernel (socket-based, request/response), returning structured execution results for rendering. Output and error capture (stdout/stderr, stack traces, and rich results where applicable) to present execution feedback clearly inside Mogan. Project-aware environment activation by automatically locating the nearest Project.toml (and using Manifest.toml when present) and executing code in the corresponding Julia environment. Integration with Julia’s Pkg workflows to support reproducible dependency management (e.g., activate/instantiate and related environment operations). My resume is enclosed in the attachment. More details are discussed in the proposal enclosed in the attachement. Thank you for your time and consideration. I look forward to the possibility of contributing to Mogan STEM this summer. Best regards, Tianyou Liu Email: liuty2025@mail.sustech.edu.cn GitHub: https://github.com/AXeonV