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.
This project aims to build a multimodal foundation model for exoplanet characterization by addressing the challenge of heterogeneous astronomical data and instrument-specific biases. It combines transformer-based models for images (protoplanetary disks) and sequential data (transit light curves), trained using knowledge distillation, masked autoencoding, and contrastive learning on both real and simulated datasets. The deliverables include pretrained multimodal models, a curated data pipeline, evaluation on real-world tasks, and a well-documented open-source codebase with reproducible workflows.
Lemke's algorithm is a method for solving Linear Complementarity Problems (LCPs). Computing equilibria for two-player games can be reduced to solving such problems. The Gambit library already has a C++ implementation of Lemke's algorithm, but the goal of this project is to improve and integrate Bernhard von Stengel's Lemke package written in Python. The current package works primarily as a standalone CLI tool, with algorithm logic, file I/O, and console output all tightly coupled. This project will transform it into a dual-purpose package – usable both from the command line and as an importable Python library that Gambit can directly call.
LuaSQL currently does not support prepared statements, which are widely used in modern database applications for performance, security, and efficient query execution. Without this feature, applications must repeatedly send full SQL queries to the database, which prevents query reuse and makes parameter binding difficult. This project will design and implement a minimal and portable prepared statement API for LuaSQL. The API will introduce a new Statement object with methods such as prepare, bind, execute, and close. The design will follow LuaSQL’s existing conventions and ensure that the interface can be implemented consistently across different database drivers. The implementation will focus on the Oracle OCI8 driver as the first complete backend. It will support parameter binding, statement reuse, cursor integration, and proper resource management. Special attention will be given to handling cursor lifecycles and ensuring consistent behaviour across different DBMS APIs. At the end of the project, LuaSQL will include a working prepared statement API, a full OCI8 driver implementation, comprehensive tests, and updated documentation so that other drivers can implement the same interface in the future.
The OWASP Agent - Module C: The Librarian (OpenCRE) project makes it possible to use continuously changing OWASP guidance inside OpenCRE, while keeping the OpenCRE graph trustworthy. OpenCRE already links stable standards well, but mapping “living” OWASP content at scale is still manual and can introduce mistakes. Module C becomes the decision boundary: it determines when a new section should automatically map to a CRE node, when an existing mapping should be updated, and when the case is uncertain and must go to human review. The Librarian follows an explicit-link-first workflow and uses a semantic fallback that retrieves the top 20 candidate CRE nodes with pgvector, reranks them with a sentence-transformers cross-encoder (ms-marco-MiniLM-L-6-v2), and applies safeguards such as negation handling, update detection, and contradiction checks. Only results scoring above 0.8 are written automatically; the rest are routed to a review queue. Deliverables include a production-ready Module C pipeline integrated with OpenCRE, a golden dataset and reproducible evaluation harness, CI regression gates to prevent quality drift, and operational documentation for calibration and maintenance. If time permits, I will also prototype hybrid retrieval (vector + BM25) for identifier-heavy cases and a lightweight human review dashboard (Module D). By the end of GSoC, OpenCRE will have a measurable, safe mapping layer that enables Project OIE to ingest OWASP knowledge without sacrificing trust.
This proposal lays out plans to bring native MPLS support into the FreeBSD kernel. MPLS—Multi-Protocol Label Switching—is a fast packet-forwarding method you’ll find everywhere in big service provider and data center networks. Instead of making routers do complex IP lookups at every hop, MPLS uses simple label swapping. The magic happens with a tiny 32-bit shim header that holds a 20-bit label, a few bits for traffic class, a stack indicator, and an 8-bit TTL. This header sits snugly between Layer 2 and Layer 3 headers, letting routers in the core do blazing-fast forwarding while pushing tough routing decisions to the network edge. FreeBSD is famous for its solid IPv4 and IPv6 networking stack, but it’s been missing native Layer 2.5 switching. That gap has made it hard for FreeBSD to get traction in provider core networks. Meanwhile, OpenBSD and NetBSD have shipped MPLS support for ages, and Linux has had MPLS built in since kernel 4.3. FreeBSD’s overdue update doesn’t just catch up—it leapfrogs the other BSDs. This project stands out in two big ways: it adds ECMP multipath support using the modern nhgrp (Nexthop Group) subsystem, and it swaps out the old, hard-to-extend rtsock interface for a much more flexible Netlink-based control plane.
VLC contains hand-written SSE2/SSSE3 assembly for performance-critical paths but has no automated correctness testing for them. This project integrates the checkasm framework into VLC's Meson build and CI pipeline, adds test coverage for all existing assembly routines, and implements new SIMD kernels for audio/video format conversions — with initial RISC-V vector groundwork.
Scenic is a probabilistic programming language for generating and verifying environments of autonomous cyber-physical systems. Its driving domain- the primary interface for autonomous vehicle (AV) testing- is a Python library that parses OpenDRIVE road-network files and exposes lanes, roads, intersections, traffic signals, and agents as first-class Scenic objects. While the driving domain is powerful, it has several concrete limitations that hinder real-world usage: assertion failures and geometry artifacts on certain OpenDRIVE maps; a coarse-grained centerline-following model that accumulates error on curved roads; incomplete extraction of semantic road metadata; and absent lane-signal linkage that makes it impossible to write autopilot behaviors that respect traffic laws. This proposal addresses all of these gaps across two major tracks and five subtasks, matching the project outline provided by the mentors: - Track 1 (~4 weeks): Robustness - fix known bugs, expand the test suite. - Track 2 (~5 weeks): Features - Frenet-frame geometry, lane-following distance, semantic tags, signal-lane linkage, and modular scenario components. Each subtask explained in the proposal will produce independently reviewable pull requests, letting mentors integrate work incrementally. The result is a driving domain that is meaningfully more robust, more expressive, and better validated than today.
This project aims to modernize Uyuni API documentation system by replacing the existing Javadoc-based macro DSL with a standardized OpenAPI/Swagger approach. The current system lacks interactivity, standard tooling support, and automated validation, leading to outdated and hard-to-maintain documentation. To solve this, I will generate an OpenAPI specification from annotated Java interfaces using a custom Swagger reader, making it the single source of truth. This specification will power interactive Swagger UI within Uyuni, ensure contract validation through automated testing, and enable generation of existing documentation formats such as AsciiDoc, DocBook, and HTML.The key deliverables include migrating 60+ API handlers to the new structure, implementing validation and contract testing, integrating Swagger UI into the web interface, and developing parsers to maintain compatibility with existing documentation pipelines.
The current Postorius subscriber management page has limited member visibility, no filtering options, and requires full page navigation to edit preferences. This proposal adds a Display Name column with sortable headers, filter dropdowns for delivery status/mode/moderation action with bookmarkable URL params, an expandable inline row for quick preference editing without page navigation, and private list visibility for subscribers with lock icon indicators.
This project aims to develop a Direct GitHub Integration Plugin for PathVisio to transform the pathway curation workflow from outdated systems to the WikiPathways GitHub repository. This proposal delivers a Java-based plugin which uses GitHub REST APIs to carry forward Git Operations. The PathVisio-GitHub Integration plugin will provide a clean and user friendly UI for biologists unfamiliar with Git Operations. The main goal of this proposal is to build an automation of Git Operations directly from PathVisio to WikiPathways GitHub repository for WikiPathways contributors. The plugin features authorization of users via GitHub using OAuth Device Authorization Grant and provides automatic forking of repositories and branching in the background using GitHub REST APIs. An encoding of GPML pathway files into Base64 format takes place before the plugin stages commits and opens Pull Requests directly from the PathVisio dashboard without freezing the main application thread. This is ensured by Java SwingWorker running in the background. Furthermore, the project integrates GitHub Actions to automatically validate file formats and metadata completeness upon final submission. Ultimately, this plugin helps to simplify complex Git operations of contributing to biological pathways, enabling the global biological research community to effortlessly work on PathVisio.
Implement MS-RDPEUSB protocol (client & server) in IronRDP with libusb backend and qemu-rdp integration. The goal of this project is to add USB device redirection support to IronRDP, the Rust implementation of the Remote Desktop Protocol. This enables client-attached USB devices (webcams, scanners, security keys, etc.) to be transparently accessed by applications running on the remote server. MS-RDPEUSB is a Dynamic Virtual Channel (DVC) extension that provides low-level USB packet redirection. Unlike high-level device redirection (like file system or audio), USB redirection transfers raw USB packets, allowing any USB device to work remotely without device-specific driver support on the client.
Sugar's Journal records everything a child creates, but reflection one of its three core design pillars amounts to an empty text box that most children never touch. There is no prompt, no conversation, no mechanism to surface what a child learned from what they made. This project adds that mechanism by embedding a conversational reflection panel directly in the Journal, powered by the existing Sugar-AI backend. When a child opens a Journal entry, A reflection buddy asks a single artifact grounded question rooted in constructionist pedagogy. The conversation is adaptive, capped, and never forced. A gentle non-blocking nudge on activity exit reminds children that Reflection Buddy is ready without interrupting their workflow. What a child says they want to try next is saved and surfaced at the start of their next session, closing the loop from Reflect back to Imagine. Offline deployments are covered by Reflection Sparks, a curated bank of static prompts. Deliverables: 1. 2 FastAPI endpoints integrated into Sugar-AI (/reflect/chat and /reflect/summary) 2. A GTK3 reflection panel embedded in the Journal view 3. Metadata persistence via D-Bus 4. A feed-forward banner 5. An offline fallback 6. Full test coverage, working across all 40+ Sugar activities without activity-specific configuration.
The Clang Static Analyzer (CSA) can find a wide range of temporal memory errors such as use-after-free and dangling references. Some of its checkers, like cplusplus.InnerPointer, rely on hardcoded knowledge about the behavior of specific APIs. The Clang community has introduced lifetime annotations: [[clang::lifetimebound]] and [[clang::lifetime_capture_by(X)]] that let developers express lifetime relationships directly on their declarations and -Wlifetime-safety makes use of them. However, in partially annotated code, a single missing annotation is enough to prevent -Wlifetime-safety from finding the bug. The CSA can help in these situations by inlining the unannotated function. In my proposed project, I intend to implement a new standalone checker that reads lifetime annotations and tracks the resulting dependencies along different execution paths, using them as a fallback when the analyzer cannot inline a function body. The expected result is that the CSA detects lifetime bugs in both annotated and partially annotated code that it currently cannot catch, complementing the coverage provided by -Wlifetime-safety.
Currently, the StablePay ecosystem only processes payments for Djed Osiris. As the Djed protocol expands to include new variants like Djed Shu, Tefnut (ETH-backed), and Isis (ERC-20-backed), the payment infrastructure must evolve. The goal of this project is to refactor the StablePay widget, merchant dashboard, and demo sites to seamlessly support any Djed variant without hardcoded assumptions. Additionally, this project will introduce support for the Gluon protocol, which entails deriving the essential mathematical formulas required for pre-calculating neutrons and protons. To achieve this, I will develop protocol adapters that interact with abstracted Djed interfaces, allowing different stablecoins to be plugged in via configuration. I will upgrade the merchant dashboard to enable multi-stablecoin management, allowing merchants to set preferred price feeds and monitor per-stablecoin revenue. Additionally, I will build deployment tooling to auto-generate config bundles from on-chain metadata and improve the end-user UX to handle coin selection, oracle status, and fallback logic gracefully. Ultimately, this project will transform StablePay into a highly scalable, agnostic payment gateway. Deliverables will be secured with comprehensive integration testing (using Foundry/Hardhat) and frontend end-to-end testing, alongside detailed documentation for merchants to easily onboard new networks and protocol versions.
The goal of this project is to provide an interface in Bespoke Synth for editing and running Faust programs in real time. This will provide Faust developers with access to a modular synthesizer that can be used as an IDE, and it will provide Bespoke Synth users with an accessible way to extend and modify the DSP of Bespoke Synth without having to recompile. This project will be implemented using C++, and will use the Faust embedded compiler.
This project transforms API Dash into a next-generation, AI-native API client. I am merging three core objectives: 1. Agentic API Testing, 2. MCP Support 3. Generative UI Visualizations into a unified Dual-Transport Model Context Protocol (MCP) Architecture: 1. Agentic Sandbox & Generative UI (GenUI): Eliminating brittle WebViews, the internal UI will utilize Google's genui SDK and the Open Responses specification. This powers two features: an autonomous, self-healing Agentic Testing Dashboard, and a "Generative UI Previewer" that visualizes rich AI responses for end-users building Flutter/Web apps. 2. Headless MCP Engine: This exposes API Dash as a standard stdio MCP Server for external Agent interfaces (like VS Code, Cursor, or Claude Desktop).
I propose to implement the Overlay Layer API for Matplotlib’s interactive backends. Currently, tools like the Cursor widget force a full figure redraw on every mouse move, making even a simple crosshair feel laggy. This project introduces a canvas-owned Overlay Manager that stores lightweight, layered overlay primitives (lines, rectangles, etc.) with in-place update handles. Overlays will be drawn independently of the main figure using the fastest available path: native GUI painting (starting with QtAgg), a blit-based fallback when possible, or a lightweight full-redraw fallback otherwise. As the minimum deliverable, I will build a fast, smooth built-in Crosshair tool (integrated with ToolManager) that works correctly with shared Axes and becomes a standard interactive feature alongside Pan/Zoom.
This proposal focuses on automating the generation of print-ready PDFs for OWASP Cornucopia by replacing the current InDesign-dependent workflow with a fully open-source, Scribus-based pipeline. It introduces a Python converter that reuses the existing YAML parsing logic to populate Scribus .sla templates, followed by automated PDF/X-1a:2001 export using Scribus in headless mode. The solution integrates seamlessly into the existing CI/CD pipeline, enabling every release to automatically produce print-ready outputs alongside current artifacts. By removing manual steps and proprietary dependencies, this approach makes the process more reliable, reproducible, and accessible, while also laying the foundation for future enhancements like customization and vendor-specific outputs.
The goal of this project is to push four nearly-finished ScummVM engines over the finish line, ensuring they are ready for official releases. Currently, these engines face issues ranging from incomplete low-level graphics and legacy code structures to unresolved gameplay bugs. How I plan to solve it: The project tackles the engines systematically. For the chamber engine, I will finalize the EGA planar graphics support and resolve memory-management issues like buffer overreads. For the avalanche engine, I will refactor the donated source code into modern C++ OOP standards, implement missing UI features, and fix gameplay logic bugs. Finally, for the DM and lilliput engines, I will conduct complete, meticulous end-to-end playthroughs to identify and fix any remaining logic, memory, or portability bugs. Deliverables: Chamber: Fully functional EGA 16-color graphics support without segmentation faults. Avalanche: A modernized, OOP-refactored codebase with a working "Shoot 'Em Up" minigame, repaired Robin Hood event trigger, missing Outro screens, and synced UI. DM & Lilliput: Stable, fully playable versions of Dungeon Master, The Adventures of Robin Hood, and Rome: Pathway to Power, fully prepared for stable public release.
OpenWISP's firmware upgrader fails permanently when devices are offline during mass upgrades, requiring manual re-triggering. There is no way to schedule upgrades for future maintenance windows. Solution: Two features for openwisp-firmware-upgrader. 1. Persistent upgrades (#379): Offline devices go to "pending" status instead of "failed" and retry automatically via Celery Beat with exponential backoff until the device comes online or an admin cancels. 2. Scheduled upgrades (#380): Optional datetime picker on the mass upgrade page. Celery Beat executes due upgrades with runtime re-validation and conflict detection. Both features compose: a scheduled upgrade that hits offline devices enters the persistence loop. Deliverables: - Model fields (persistent, retry_count, next_retry_at, scheduled_at) with additive migrations - Modified failure handler with pending status branch - Celery Beat tasks for periodic retries and scheduled execution - Admin UI: persistent checkbox, datetime picker, pending/scheduled status display - REST API with full admin parity - Notifications via generic_notification - Selenium browser tests, documentation, usage videos
Build the Policy Audit Point (PAP) for ACF-SDK that fires real attack payloads through the enforcement chain, records what gets caught and what slips through, and produces a coverage matrix. Includes 50+ attack patterns mapped to OWASP LLM Top 10, pytest integration, OpenTelemetry trace emission, and regression testing for policy changes. Structured as a research pre-registration targeting ACM AISec or IEEE S&P DLSP Workshop
Like many large scale software projects, OpenMS has numerous development dependencies. Unfortunately, there is no straightforward way to quickly and easily install all of these dependencies. Some can be installed using various package managers such as apt-get, brew, or choco, while others need to be installed with a Python package manager such as conda. And finally, some dependencies need to be compiled from source code manually. The proposed solution introduces a vcpkg manifest-based dependency system integrated through CMake toolchain support. To address performance challenges, especially for large dependencies such as Qt, a binary caching mechanism will be implemented using GitHub Releases, significantly reducing build times in both CI and local development environments. Existing contrib patches will be analyzed and minimized by leveraging upstream fixes and vcpkg ports, with overlay ports introduced only where necessary. The project will deliver a fully functional vcpkg-based build system for OpenMS, including cross-platform support (Linux, macOS, Windows), CI integration with caching, and validated compatibility with core components and pyOpenMS. This will improve build reproducibility, reduce maintenance overhead, and simplify the developer onboarding process.
This project extends the Raspberry Pi 4b BSP in RTMES by adding Framebuffer, SDHCI and PCIe support. Building on mailbox and DMA support added during GSoC 2025, this project completes the SDHCI work pending since GSoC 2024 and adds framebuffer otuput via the VideoCore mailbox property tags interface. PCIe support will be ported to rtems-libbsd. In this proposal I have detailed how I will go about adding support and testing each driver.
This project integrates n8n, a no-code workflow automation platform, with OpenVINO Model Server to let users build AI-powered workflows that run on Intel GPUs and NPUs. The core is a custom n8n node package that connects to OVMS - users pick a model, choose a target device, and the node handles inference. The system is deployed through Podman Compose with one command. The primary workflow is a Smart Document Processing Pipeline: it watches a folder for incoming documents, runs text extraction on NPU, classifies and extracts entities using an LLM on GPU, and saves results locally. OpenVINO's AUTO plugin handles device selection automatically based on availability and load. Deliverables: custom n8n node package with GPU/NPU/AUTO device selection, Podman Compose deployment, the document processing pipeline, 2-3 additional workflow templates (RAG chatbot, multimodal content analysis), and documentation with installation guide and tutorials."