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 XaoS is a real-time interactive fractal zoomer that currently lacks a mobile-optimized UI. This project will: (1) implement a touch-friendly QML mobile UI with pinch-to-zoom, swipe-to-pan, and gesture-based fractal navigation, (2) deploy stable Android and iOS builds via Qt for Android/iOS toolchains, and (3) build a community sharing protocol for users to save, browse, and download fractal creations. I have already built a working prototype with a complete QML interface, adaptive rendering, and a signed Android APK running on a physical device. The engine integration, cross-compilation, and touch gesture handling are fully de-risked.
This project aims to develop an AI-powered tool for automated heuristic evaluation of digital interfaces, addressing the limitations of manual usability analysis, which is time-consuming and requires expert knowledge. The proposed solution combines rule-based evaluation using established usability principles, such as Nielsen’s heuristics, with artificial intelligence techniques to analyze interfaces, detect usability issues, and generate both quantitative scores and qualitative insights. This hybrid approach improves efficiency, consistency, and accessibility of usability evaluation. The project will be developed using the Scrum methodology, with iterative sprints and continuous feedback. As an open-source solution, it will support collaboration and future extensions by the community. Key deliverables include the system architecture and prototype, a heuristic evaluation engine, an AI-based analysis module, an automated report generation system, and complete documentation along with the final release.
Development teams using OWASP Cornucopia for threat modelling have no automated way to turn played cards into actionable Jira user stories - this translation is done manually, inconsistently, and often skipped altogether. This project builds a proof-of-concept AI agent that closes that gap. Given a card ID from a played session, the agent calls the Cornucopia REST API, retrieves semantically similar context from a Qdrant vector store, and uses Google Gemini to generate a security requirement, a Gherkin user story, and two BDD test cases. A human reviewer approves the output before any Jira ticket is created - keeping security decisions with the team. Deliverables: a working end-to-end pipeline with Jira integration, human-in-the-loop review, unit and integration tests, and full setup and usage documentation. The foundation is designed to continue developing beyond GSoC.
This project proposes a secure, scalable push-based API designed to transform GreedyBear into an open data sink for the global honeypot community. The architecture focuses on high-performance ingestion by capturing raw telemetry from external sensors and offloading tasks directly to Django-Q for asynchronous processing. By utilizing Django-Q’s native task queuing and buffering capabilities, the system ensures non-blocking event ingestion and high responsiveness. This design emphasizes architectural efficiency and full integration with the existing IOC extraction, merging, and scoring pipelines, allowing for robust normalization and data consistency without the need for redundant storage layers.
This project completes the architectural transition of the HPX parallel runtime to the C++26 Sender/Receiver (S/R) model. Building upon the recent cleanup of legacy execution code, I will advance HPX from an "adapter-based" architecture to its "Native Architectural Phase." This involves refactoring the core execution boundaries of make_future and keep_future to remove internal implementation dependencies (such as the __loop_ pointer) and porting distributed subsystems like MPI and CUDA to be native, first-class stdexec citizens. My primary objective is to eliminate technical debt and achieve zero-overhead integration with the C++26 execution standard while ensuring full backwards compatibility for all existing HPX applications.
The CONCORE framework requires a high-performance Julia bridge to handle complex control loop simulations without inheriting bloated dependencies. This project delivers concore-jl, architecting a strict separation between a zero-dependency core I/O protocol (Concore.jl) and optional parsing utilities (ConcoreUtils.jl). The final deliverable guarantees sub-sample state synchronization, comprehensive cross-language interoperability (Julia/Python/C++), and a fully automated CI/CD pipeline for analytical validation.
Current radiospectra stores spectral data as plain NumPy arrays with each instrument client handling metadata, axis ordering and coordinate conversions differently. This leads to inconsistencies and requires users to write boilerplate code for common tasks such as slicing by time or frequency, performing background subtraction and working with physical coordinates. It also limits integration with SunPy's coordinate-aware ecosystem like NDCube and WCS. This project proposes developing a single Spectra class that provides a consistent, high-level interface for radio spectrogram data. The class will support intuitive slicing using physical coordinates, built-in background subtraction and simplified visualisation while abstracting underlying array complexities. The project will explore integrating NDCube or alternative approaches such as xarray or a custom WCS layer to ensure the best fit. The goal is to make radiospectra as user-friendly and consistent as sunpy.map, improving usability and interoperability across the SunPy ecosystem.
NetGuardian is a zero-trust ingestion and triage pipeline that connects distributed security producers to BLT. A Cloudflare Python Worker sits at the center of it all: it verifies signed `ztr-finding-1` envelopes using JCS and HMAC, enforces replay protection and RBAC, stores metadata in D1, keeps encrypted evidence in R2, and enriches findings through BLT-API for CVE-aware scoring and issue creation. An events outbox handles delivery to any downstream consumers. The Worker also serves a static triage UI where operators can review verified findings and kick off fix workflows, either through PRs or BLT issue paths. On the deliverables side: versioned ingestion and triage APIs with a full OpenAPI contract, the end-to-end swarm dataflow with evidence storage, observability and rollout gates with SLOs, and a midterm slice to validate performance and correctness before the project is fully built out.
SciCommons is an open source platform for researchers to interact, review, and discuss scientific papers. My project focuses on making the platform a more powerful tool for daily research. I will build a browser extension that lets users import articles instantly from sites like arXiv, PubMed, and Nature. I will also build an AI summarization feature using locally hosted Ollama models to help researchers process papers faster. To keep the site fully accessible for everyone, I will expand our automated testing coverage using PlayWright and Axe-core. Finally, I will integrate real-time social feeds on home page and a new split-pane preprint viewer to improve how we discover and read research papers.
Throughout the project, I want to focus on Zulip's native integrations and incoming webhooks framework by working on incomplete and pending features, fixing and enhancing integrations, and improving the user experience. I am willing to commit 40 hours per week over a span of 12 weeks, delivering high-quality, impactful contributions in this area.
This project aims to bring GraalVM native-image support to JabRef, starting with JabKit and its core dependency JabLib, and then extending to JabGui, JabLS, and JabSrv based on feasibility. Currently, JabKit is distributed using JPackage and JBang, which leads to relatively slow startup time for a CLI tool. Native-image can compile Java applications into standalone executables with faster startup, but applying it to a large modular project like JabRef is challenging, especially due to runtime issues. Based on preliminary experiments, the main difficulty is not compilation but runtime compatibility. Dependencies such as Lucene, PDFBox, and JGit can compile successfully but fail at runtime due to dynamic class loading, reflection, or native library requirements. This project follows an incremental approach. First, it establishes a minimal native-image build and testing setup. Then, it enables a subset of JabKit functionality and gradually expands support by resolving dependency issues. Finally, it investigates feasibility for JabGui, JabLS, and JabSrv. Expected deliverables include a working JabKit native executable, feasibility results for other components, and documentation on dependency compatibility and native-image configuration.
DORA lacks testing infrastructure. Debugging multi‑node dataflows means manual node isolation—slow and fragile. This project delivers `dora-test-utils`: a Rust crate that adds unit testing (NodeHarness), integration testing (TestSourceNode/TestSinkNode), and optional record/replay for regression. Deliverables include mock APIs, example pipelines, documentation, and CI templates. The work is scoped as a 175h MVP with a +175h extended version.
An LLM-assisted, human-supervised pipeline to extract, interpret, and reconstruct agronomic and ecological experiment data from scientific papers into structured, BETYdb-compatible records. The system uses an intermediate representation (IR) with field-level provenance (extracted/inferred/unresolved), deterministic validation, and experimental reconstruction logic to ensure accuracy, consistency, and traceability, significantly reducing manual effort and improving data quality and scalability.
This GSoC 2026 project proposes an advanced, open-source computational pipeline for the Late Antiquity Modelling Project (LAMP) to reconstruct historical movement and visual connectivity, moving beyond deterministic archaeological GIS with a data-driven, modular approach. The core objective replaces standard Least-Cost Path analysis with a Probabilistic Path Ensemble. Utilizing Maximum Entropy Inverse Reinforcement Learning (MaxEnt IRL), the pipeline autonomously learns historical cost weights by balancing terrain slope against surface friction derived from K-Means clustered SAR and Multispectral imagery. Additionally, the routing engine leverages spectral anomaly detection and structure tensors to uncover subtle pathways hidden in the landscape. The project's second pillar introduces 3D Viewshed Analysis. By processing high-resolution terrain geometry (.obj files) to calculate precise 3D lines of sight, the toolset enables researchers to evaluate the visual prominence and strategic interconnectivity of ancient settlements and outposts. Built over 12 weeks using robust Python geospatial libraries (Rasterio, GeoPandas, SciPy), the final deliverable is a scalable, mathematically rigorous toolkit. It will serve immediate LAMP needs at sites like El Bagawat while remaining seamlessly transferable to any archaeological context requiring advanced spatial modeling.
SageMath currently has various examples of Hopf Algebras implemented, such as symmetric functions, quasisymmetric functions, word-quasisymmetric functions, etc. along with some of their bases. This Google Summer of Code project aims to implement an example of Hopf Algebras- the supersymmetric functions along with bases such as (double) powersum, elementary, homogeneous and Schur supersymmetric functions. The addition of supersymmetric functions and these bases would aid in research computation of their characterization and combinatorial interpretation.
NixOS is uniquely positioned to generate accurate, reproducible Software Bills of Materials (SBOMs) from its declarative build graph, yet current SBOM generators must infer Package URLs (PURLs) from package names and heuristics leading to inaccuracies that matter under regulations like the EU Cyber Resilience Act. This project fixes the problem at the source: 1. by enriching nixpkgs package metadata so that correct PURLs are embedded directly into derivations, eliminating guesswork downstream(SBOM generators like bombon, sbomnix etc). The core blocker is that passing meta attributes through .drv files currently risks triggering massive content-addressed reverse dependency rebuilds. This project will help land the key upstream PRs (notably Robert Hensing's PR #14686 / nixpkgs #466932) that allow selected metadata to flow into .drv without affecting store path computation. With that foundation in place, a systematic series of nixpkgs PRs will enrich packages that currently carry inaccurate or missing PURL metadata, while coordinating with SBOM tool authors (e.g. bombon, Syft, sbomnix) to reduce heuristics and consume the authoritative data. Deliverables: 1. community coordination to get the PRs blocking enrichment merged 2. a batch of nixpkgs enrichment PRs covering packages with known PURL inaccuracies 3. upstream patches or issues filed against SBOM generators to adopt the enriched metadata
This project aims to develop a robust crisis signal detection system that identifies reliable mental health distress signals from social media data. It addresses key challenges such as bot amplification, media-driven spikes, and sparse data that can distort real-world crisis trends. By combining sentiment analysis, volume tracking, and clustering at the regional level, the system computes a confidence-adjusted crisis score. A human-in-the-loop mechanism prioritizes high-risk signals for review, ensuring responsible decision-making. The final deliverables include a crisis scoring framework, bias detection system, escalation pipeline with human validation, and an audit logging mechanism to support transparency and continuous monitoring.
This project aims to develop a napari-based GUI for interactive correction of pose-estimation tracks within the movement framework. It will enable users to resolve identity swaps in multi-animal datasets and correct keypoint errors efficiently. In multi-animal tracking, automated pipelines often fail due to occlusions, noise, and identity ambiguity. The proposed tool integrates visualization and editing into a unified workflow, allowing users to inspect and refine trajectories directly while maintaining standardized data structures. This will improve the quality and reliability of pose-estimation datasets, providing the open-source community with a robust and extensible solution for behavioral data curation. This project builds on an initial napari-based prototype that I have already developed for manual trajectory correction.
The Julia GPU ecosystem allows users to write array programs that run seamlessly across NVIDIA, AMD, and Intel GPUs. This functional portability relies on GPUArrays.jl, which defines the common interface implemented by all vendor packages. However, several foundational operations currently lack shared implementations. Operations such as reverse, findall, accumulate!, and mapreduce either crash on backends lacking a vendor override or silently degrade to CPU execution by copying data back and forth. A direct source audit of GPUArrays.jl (v11.4.1), CUDA.jl, AMDGPU.jl, oneAPI.jl, and Metal.jl confirmed these gaps: reverse and findall are entirely absent from the shared fallback layer, accumulate! exists only as a scalar CPU fallback, and mapreducedim! is declared as an error("Not implemented") stub, forcing every backend to maintain isolated, vendor-specific implementations. This project resolves these portability gaps by establishing a cleaner, more robust architecture: moving critical GPU kernels upstream to AcceleratedKernels.jl (AK.jl) while refining GPUArrays.jl into a lightweight, pure delegation layer. Building upon the newly introduced KernelIntrinsics API, this approach implements highly optimized, vendor-neutral kernels directly within AK.jl. Because Julia’s multiple dispatch inherently prefers the most specific method, routing AnyGPUArray fallbacks to AK.jl means backends with existing optimized vendor methods remain untouched, while backends missing the functionality automatically receive high-performance GPU execution instead of a crash or silent slowdown.
The project will develop a high-performance Rust backend for graph-based spatial smoothing of hyperspectral images, delivered through an R package, hyperspec.rust. The package will bridge R’s dgCMatrix format to Rust’s faer sparse matrix structure, establishing a reusable FFI pattern for R–Rust interoperability. On the Rust side, pixel neighborhood graphs will be constructed using petgraph, with configurable connectivity to minimize data transfer. Spatial smoothing will be implemented by solving the sparse linear system (I+αL)x=b using iterative solvers (CG/BiCGSTAB) from faer. The project will include tests and benchmarking against pure-R implementations on large datasets along with documentation and a vignette to demonstrate smoothing. Additional goals include CRAN release of hyperSpec.rust, publishing the FFI bridge pattern as a Rust crate, and a JOSS paper.
The p5.js Web Editor has no end-to-end tests. As the team works through a TypeScript migration and backend refactor, regressions in core user flows can go undetected and only surface through manual review. This project builds a complete E2E testing suite using Playwright, integrated into GitHub Actions so every PR into the develop branch is automatically validated against real user behaviour. The three deliverables are a working CI pipeline that runs the E2E suite on every PR, a set of prioritised user flows covering unauthenticated, authenticated, and state-transition scenarios, and contributor documentation so the suite can be extended after GSoC without the original author present.
LLMs rely on floating-point arithmetic for inference, but the Logarithmic Number System (LNS) offers a compelling alternative: multiplication becomes integer addition in the log domain, and 16-bit LNS (xlns16) uses only 2 bytes per element, half the memory bandwidth of float32. This project integrates the open-source xlnscpp C++ LNS library into ggml (the compute backend of llama.cpp) as a proper ggml_backend, enabling LLM inference to run entirely in xlns16 arithmetic as a proof of concept. The implementation introduces GGML_TYPE_LNS16 as a native ggml datatype and implements the 13 operations required for a complete transformer inference pass (matrix multiply, softmax, RMS norm, RoPE, SiLU, residual add, along with some others), all using xlns16 kernels. Activations stay in xlns16 format throughout inference; weights are converted dynamically from their stored quantised formats (Q4_K_M, etc.) per kernel invocation using O(1) lookup tables. The backend is validated at two levels: a unit test confirms sub-0.6% relative error on matrix multiply, and an end-to-end run on SmolLM2-135M-Instruct confirms the full transformer executes without crashing. Deliverables: (1) GGML_TYPE_LNS16 datatype registered in ggml; (2) a complete ggml_backend for xlns16 arithmetic covering all ops needed for LLM inference; (3) integration with llama.cpp; (4) a validation test suite; (5) an accuracy analysis comparing LNS and FP output across model layers
Modernize the Sample Platform with 8 targeted improvements: (1) a unified AI-friendly endpoint that serves all test artifacts — binaries, logs, inputs, outputs from a single URL with signed download links; (2) a has_ever_passed flag to distinguish regressions from tests that never worked; (3) a React-based test management dashboard replacing raw SQL workflows; and (4) a smarter diff algorithm using difflib. SequenceMatcher with subtitle-aware parsing to eliminate cascading mismatches; (5) automated git bisect to pinpoint the exact commit that introduced a failure; (6) cross-platform comparison views for Linux, Windows, and macOS results; and (7) macOS testing support via GitHub Actions runners. (8) Test Suite Expansion
Currently, VulnerableCode lacks built-in insights to demonstrate its effectiveness. This project addresses this by integrating a telemetry dashboard into the Web UI to visualize reliability, growth, and data quality.