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.
Implement distributed Dask arrays for generating true-color Rayleigh-corrected aerosol storm imagery in real time.
Implement automated demodulation routines in GNU Radio for CubeSat telemetry downlinks in UHF and S-band frequencies.
Add general relativistic acceleration perturbations and non-spherical solar radiation pressure drag models for deep space probes.
Implement GPU-accelerated non-equilibrium line-by-line spectral synthesis for high-temperature exoplanetary atmospheres.
Build fast PyOpenCL filtered back-projection (FBP) reconstruction filters for high-speed material science beamline measurements.
Build real-time MQTT 5.0 push notifications and GeoJSON trajectory streams for tracking orbital environmental sensors.
Build a mobile-first catalog of active scholarships, GSoC roadmaps, and interview preparation materials.
Simulate electrochemical Li-ion battery degradation cycles over 15-year orbital lifetimes under cyclic orbital eclipses.
Implement 3D tetrahedral adaptive remeshing routines for spacecraft heat-shield reentry thermal simulations.
NeoRoo currently talks to DHIS2 through raw HTTP calls with no offline support, so if a nurse loses connectivity while entering baby data, that data is just gone. I'm proposing to integrate the d2 Android SDK as the primary sync engine and build a Flutter abstraction layer on top of it that works across both Android and iOS. The main deliverables are: a Pigeon-based platform bridge to d2 (Android) and DHIS2 REST API (iOS), an offline-first sync queue using Drift/SQLite with automatic retry, a server-wins conflict resolution system with a review log, real-time sync status indicators in the UI, background sync with battery optimization, push notifications for server-side changes, and a testing + monitoring toolkit. By the end, healthcare workers should be able to use NeoRoo reliably regardless of connectivity.
This project aims to implement a WESTPAParser and a WESTPAReader in WESTPA which will expose WESTPA’s HDF5 Framework simulation data as a standard MDAnalysis Universe. Currently, users are required to write extensive boilerplate code to manually navigate the HDF5 simulation data via WESTPA’s w_crawl before any structural observables can be computed. This project replaces that manual process by allowing users to obtain an MDAnalysis Universe directly from a west.h5 simulation file. This native integration will be accessible through both a Python API and a new w_mdacrawl CLI tool, serving as a high performance drop-in replacement for existing workflows. The project will also allow users to use MDAnalysis’s AnalysisBase backend to perform analysis using parallelization. Furthermore, the project will also implement a method to save the resulting analysis results back into the HDF5 framework as auxdata. This will ensure that any computed properties remain compatible with the broader WESTPA ecosystem for use in future simulations or downstream analysis tools like w_ipa.
Historically, rustup has relied on $RUSTUP_HOME (defaulting to $HOME/.rustup) and $CARGO_HOME (defaulting to $HOME/.cargo) as monolithic directories for configuration, state, and data. In coordination with the Cargo team, this proposal aims to migrate `rustup` to use the standardized XDG Base Directory Specification on Linux. To achieve this safely, we will transition from a "dual-directory" approach to a "fine-grained" directory approach, unblock Cargo's own XDG migration, and establish a strict backward-compatibility protocol for existing installations.
The recent efforts of the `scala-wasm` project have made it possible for Scala to use the WebAssembly Component Model binary format as a compilation target. Although, the implementation has not yet been finished, it is already possible for developers to run Scala code on Wasm runtimes. In order for the Scala language to succeed in the Wasm ecosystem, core libraries which rely on platform APIs must be ported to the Wasm/WASI platform. The goal of this project is to prototype porting the core parts of the Cats Effect and FS2 libraries to the Wasm/WASI platform. The CE runtime prototype will be single-threaded and based around `wasi:io/poll`. The end result is expected to be similar to the (now-replaced) single-threaded LLVM runtime which used a `libuv`-style event-loop. The FS2 porting effort is going to focus on `fs2-core` and the `network` and `file` APIs from `fs2-io`. As a part of this project, a standalone reimplementation of java.nio.file API will be developed as a separate library. Planned Deliverables: 1. A working prototype of Cats Effect's single-threaded runtime compiling and running on Wasm/WASI free of glue JavaScript code. This prototype will serve as a basis for an upstream implementation. 2. Prototype port of the core FS2 module and the fs2.io.file and io.network APIs. 3. A standalone library reimplementation of JDK file APIs for WASI. Initial scope of the implementation will be adjusted to the needs of the fs2.io.file port. 4 An extensive documentation of the project. 5. A report regarding implementation details and findings discovered over the course of the project which will help with further porting efforts of Scala compilers and other platform-dependent libraries. 6. Wasm test environment and CI created for this project can upstreamed to sbt-typelevel so that it can be used in other projects.
The Network Simulation Bridge (NSB) is a powerful co-simulation framework, but its current onboarding experience creates a barrier for new users due to fragmented documentation, absence of a clear “first success” path, and setup complexity. This project aims to design and develop a user-centric website that transforms onboarding into a structured and intuitive flow. The core focus is enabling users to run a working NSB example quickly through a quickstart-first approach, followed by progressive introduction of concepts, configuration, and simulator integration. The solution includes building a complete website with a guided Get Started system, reorganized documentation, and clearly defined learning paths, along with a progressive simulator integration strategy that begins with a simplified environment before moving to full simulator workflows. Key deliverables include a deployable NSB website with structured navigation, a guided onboarding flow centered on first success, unified documentation migrated from the repository, and tutorials with progressive learning pathways, validated through user testing and iteration. This project will reduce onboarding friction, improve usability, and make NSB more accessible to students, researchers, and developers.
Mifos is moving toward a more modular architecture, but many large modules still rely on direct dependencies, which makes the codebase harder to maintain, test, and evolve. This project aims to address that problem by introducing an event-driven approach for stand-alone modules, using Spring’s application event publisher to replace one-way direct calls wherever possible. The goal is to reduce tight coupling between modules, especially in areas such as loan, savings, and group support, so that modules can become more independent and easier to package, reuse, and publish separately. The project will focus on identifying suitable direct dependencies, designing event-based replacements, implementing publishers and listeners, and validating that the new flow works cleanly without breaking existing behavior. The final deliverables will include the architectural changes needed to support event-driven communication, working implementations for selected module interactions, tests and documentation for the new design, and clear guidance for extending this pattern across the Mifos platform in the future. The broader outcome will be a cleaner and more scalable modular foundation for Mifos, making it easier for the community to build and maintain true stand-alone modules over time.
Advanced magnetic resonance imaging techniques, such as RF pulse optimization, increasingly rely on complex, high-performance physical simulations like those defined in KomaMRI.jl. Currently, integrating these simulations into optimization loops is bottlenecked by the lack of native gradient propagation. This project aims to unlock gradient-based optimization within the Koma ecosystem by enabling reverse-mode automatic differentiation (AD) as a first-class feature. By systematically integrating state-of-the-art AD tools, specifically Enzyme.jl and Reactant.jl, this project will make both the standard BlochSimple method and the highly optimized, custom Bloch GPU kernels fully differentiable. Core deliverables include establishing AD correctness baselines against FiniteDifferences.jl, designing a memory-efficient Simulation data structure to minimize device-host transfers, and resolving low-level upstream compatibility issues with CUDA.jl and Enzyme. Ultimately, this project will provide the Julia MRI community with a robust, fully differentiable simulation stack, culminating in an interactive tutorial for 1D RF pulse optimization.
The goal of this project is to provide a Model Context Protocol (MCP) server that is suitable for production and exposes expected REST endpoints from the European Nucleotide Archive (ENA) as organised, schema-driven tools for AI systems. Although ENA offers robust REST APIs for biological data access, direct integration with AI agents frequently results in inconsistent queries, low reproducibility, and lack of validation. In order to overcome this, the project implements an MCP-based interface layer that ensures predictable execution, provides a strict input/output schemas, and enables secure, secure communication with ENA services. A dynamic tool registry for flexibility, Pydantic for schema validation, httpx for asynchronous API communication, and a response normalisation layer for consistent outputs are all features of the FastMCP-built system. To ensure scalability and production readiness, it will also include a comprehensive error handling, testing, and containerised deployment using Docker and Kubernetes. A fully functional MCP server with several ENA capabilities (such as study, sample, and run queries), thorough test coverage, developer-friendly documentation, and a deployable system that is simple to interface with AI clients are some of the key deliverables. This project will enable more dependable AI-driven scientific workflows by improving the reproducibility, traceability, and accessibility of biological data.
This proposal addresses the need to provide game developers with a Vibe Coding Agent, an intelligent assistant capable of generating assets, writing code, and automating the Godot editor from natural language to complete complex tasks. To support this, it develops a decoupled, CPython-based framework. The solution includes a native GDScript editor plugin that captures scene context and communicates via non-blocking asynchronous HTTP requests, paired with a powerful FastAPI backend. This backend utilizes Pydantic for strict schema validation, an Agentic Core to translate user prompts into structured actions, and a Persistent Memory module to maintain project state across editing sessions. Deliverables include a non-blocking Godot plugin, the CPython backend planning layer, initial implementations for the Agentic Core and Persistent Memory, a virtual container for safe code execution, and comprehensive documentation and tests.
Automotive Grade Linux's modern Flutter UI framework lacks native Bluetooth connectivity. The legacy Bluetooth services cannot be reused because they depend on afb-daemon, unavailable in the current runtime. This project builds a native C++ Bluetooth plugin bridging Flutter with the open-source BlueZ stack via typed MethodChannels. Deliverables include a Yocto layer for system dependencies, a reliable Bluetooth abstraction library, a reactive settings UI for device pairing, and A2DP/AVRCP integration in the media player. Stretch goals include HFP telephony, PBAP contacts, and MAP messaging. This demonstrates production-grade automotive audio routing using purely open-source technologies.
The Virtual Brain (TVB) provides an open-source simulation framework for whole-brain network modeling. Unlike the traditional approach of using neurons at micro-scale level, TVB takes into account the brain regions and their interactivity. This proposal aims to enhance the TVB ecosystem by developing and improving interactive JupyterLab widgets — BCT metrics projection viewer, Connectivity_react widget and Unified Head widget. The new widgets proposed will extend TVB's analytical capabilities and improve the overall user experience for researchers studying large-scale brain connectivity patterns.
The JSON Schema validation test suite currently maintains a separate folder for each released version of the specification. This means most tests exist as identical copies across multiple folders, and every new test or bug fix must be applied in several places. This does not scale. The annotation test suite already solves this problem using a `compatibility` field that indicates which versions each test applies to, allowing test runners to filter accordingly. This project brings that same approach to the validation test suite, collapsing all per-version folders into a single unified suite with no duplicate tests.
HiperHealth's clinical pipeline currently lacks visual diagnostic capabilities. This project adds a modular MedVision skill channel, an external, installable module that brings medical image analysis into the existing pipeline with zero core modifications. The project delivers shared infrastructure (MONAI preprocessing, Grad-CAM explainability, structured Pydantic output models, confidence calibration) and two body-region skills: SkinAnalysisSkill (DINOv2 backbone, ISIC 2018 dataset) and a second body-region skill (Eye/Nail) to validate extensibility. Each skill automatically enriches the DiagnosticsSkill's differential diagnosis via the prompt_fragments mechanism, producing calibrated predictions with saliency maps for clinical transparency. The project includes Fitzpatrick fairness auditing and ≥90% test coverage.
This project adds OAuth 2.0 support to the Jenkins email-ext plugin, addressing the deprecation of basic SMTP authentication by providers like Microsoft and Google. It integrates with the oauth-credentials framework to securely obtain access tokens and enables XOAUTH2-based SMTP authentication using Jakarta Mail. The solution is provider-agnostic, allowing compatibility with multiple email services. Deliverables include OAuth integration, UI updates for configuration and credential selection, a test email feature, comprehensive test coverage, and full documentation, while maintaining backward compatibility with existing authentication methods.
The objective of this project is to develop an application that connects to a Liquid Galaxy installation. The application will be developed using Dart/Flutter and will be structured into two main components: a backend and a frontend. The CHE project offers a visual and interactive experience that allows users to explore different historical sites in a city or a country. In my case, the project is focused on the city of Lleida. The CHE project is developed on the Liquid Galaxy platform, where Google Earth is displayed continuously and synchronously creating a unified panoramic view. On top of this visualization, KML files are integrated to display information about the different historical places in the city, allowing users to easily locate and explore them in a simple and intuitive way.