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.
WebAssembly's call stack limit is unspecified by the spec and varies across host environments. As a result, any Kotlin/Wasm program that uses mutual recursion or deep tail calls is vulnerable to stack overflow at runtime, with no way to guarantee safe execution across browsers and runtimes. Kotlin's existing tailrec modifier mitigates this for simple self-recursion by rewriting functions as loops, but it cannot handle mutual recursion or indirect calls, and requires an explicit annotation that many developers will not add. The WebAssembly Tail Call proposal (standardized and part of the Baseline target since 2024) addresses this at the instruction level with return_call and return_call_ref, which discard the current stack frame before transferring control and reduce stack consumption from O(n) to O(1) regardless of recursion structure. This project integrates that proposal into the Kotlin/Wasm compiler backend. The work covers adding the missing RETURN_CALL opcode to the Wasm IR layer, detecting tail call positions in the code generation pipeline and emitting return_call and return_call_ref in place of the current call + return two-instruction sequence, writing a test suite covering mutual recursion and virtual dispatch across multiple host environments, and benchmarking return_call against the existing loop transformation to evaluate the tradeoffs.
This project focuses on solving a real gap in the current research workflow that is the disconnect between running experiments and turning those results into clean, publication-ready outputs. Right now, tools like Visdom are great for live experiment visualization, but the moment a researcher wants to use those results in a paper, everything becomes manual. Plots are exported as screenshots or loosely formatted images, experiment configurations are tracked separately (often in notes or notebooks), and comparisons across differnent runs are done by hand. This makes the process slow, error-prone, and difficult to reproduce. The proposed solution is to extend Visdom into a complete “experiment-to-publication” pipeline. Instead of stopping at visualization, the system will allow researchers to directly generate structured, reproducible, and publication-quality outputs from Visdom itself. The project introduces four tightly connected components: A publication-quality export engine that allows plots to be exported in formats like SVG, PNG, and PDF with proper resolution and formatting suitable for academic journals. An experiment metadata tracker that automatically records configurations, parameters, environment details, and results for every run, ensuring full reproducibility. A LaTeX generation system that converts plots into ready-to-use LaTeX figure blocks, eliminating the need for manual formatting in Overleaf or similar tools. A multi-experiment comparison suite that enables researchers to compare different runs with statistical summaries and generate both plots and tables for inclusion in papers. By building this system, Visdom evolves from a visualization tool into a full research workflow assistant. The end result is simple: what currently takes days of manual effort can be reduced to minutes, while also improving the reproducibility and consistency across various experiments.
The U.S. Forest Service's Aerial Detection Survey (ADS) program has produced tens of thousands of hand-drawn polygons marking forest health damage from aircraft. Due to GPS imprecision and flight geometry, these polygons have systematic spatial offsets of 50–500 meters from their true locations in NAIP satellite imagery. This project builds an automated pipeline to align ADS polygons with NAIP data, recovering historical annotations as a training dataset for forest health computer vision models. The GSoC work focuses on three objectives: (1) improve alignment accuracy through a learned refinement layer using self-supervised displacement estimation techniques from the mentor-provided references, (2) scale the pipeline to all ~48,000 Oregon ADS polygons to generate a weak training dataset, and (3) fine-tune a DeepForest model on the aligned annotations for NAIP-based forest health outbreak detection. Deliverables: an optimized alignment pipeline with quantitative evaluation, aligned polygon GeoPackage for Oregon ADS data, a computer vision model for forest health detection on NAIP imagery, and a blog post documenting the methodology for others to apply to their own datasets.
This project will add distributed linear solver support to LinearSolve.jl by expanding and hardening PETSc.jl integration. The goal is to let SciML users solve large-scale systems (Ax=b) on HPC clusters through the same high-level LinearSolve API they already use for local solvers. The work will focus on implementing and improving PETSc-based KSP wrappers, cache-aware re-solve workflows, preconditioner configuration, and distributed matrix/vector support with MPI. It will also include tests, benchmarks, and documentation so users can reliably switch between direct, iterative, and distributed methods without changing downstream solver code.
Device trees tell the Linux kernel how hardware is laid out. Currently, many of the rules for these device trees are written in plain .txt files. Because they are just text, they cannot be tested automatically, which forces maintainers to manually hunt for typos and missing properties during code review. The goal of this project is to convert a large number of these legacy text bindings into strict YAML schemas. Moving to YAML allows the build tools to automatically validate the hardware descriptions before the code is ever merged, saving everyone a lot of time. In addition to converting the bindings, the project includes tracking down and fixing the older hardware .dts files that inevitably fail when tested against these new, stricter rules, ensuring that everything builds and validates perfectly.
The istSOS backend already provides strong support for time-travel queries and versioned data through parameters like as_of and from_to. However, these capabilities are currently only accessible through manual API usage, which makes them difficult to use for most users. This project focuses on bringing these features into the web administration UI by building an intuitive and accessible interface for exploring historical data. Users will be able to select a specific timestamp or time range, view the exact past state of entities such as Things, Sensors, and Datastreams, and understand how data evolved over time without writing API queries. The approach is to design lightweight frontend components that map user input to existing backend parameters, keeping the backend unchanged while making the feature usable. In addition, a Commit History Viewer will be implemented to allow users to browse changes, view metadata like author and timestamp, and load past snapshots directly into the UI. By the end of the project, istSOS will have: - Time selection controls integrated into the UI (instant and range) - Historical views for all major entities - A commit history explorer for tracking data changes - A clean query mapping layer between UI and API - Proper testing and documentation for long-term maintainability Overall, the goal is to make time-travel functionality a first-class feature in istSOS, improving transparency, usability, and accessibility for both technical and non-technical users.
MetaCall Core is a polyglot runtime written in C/C++ that enables seamless cross-language function calls. Like any large native codebase, it is susceptible to memory leaks and unsafe memory access patterns that are difficult to detect manually and invisible in standard CI. This project improves memory tracking and code coverage reporting across platforms through six deliverables: (1) a Valgrind memcheck CI pipeline integrated into GitHub Actions — already implemented and merged pre-GSoC; (2) systematic fixes to the ~5,579 memory leaks currently detected by CI, reduced from ~99,578 through pre-GSoC contributions (PRs #706, #723, #726); (3) an improved reflect_memory_tracker.h that records file, line, and call-site information for every allocation instead of just counting them; (4) a custom lightweight instrumentation layer using LD_PRELOAD or weak symbol overriding for environments where Valgrind is unavailable; (5) enhanced CI error visibility that surfaces sanitizer-style output for failing tests instead of silent segfaults; and (6) documentation covering the new tracker API, Valgrind output interpretation, and per-loader suppression file strategy. The end result is a MetaCall codebase where memory issues are caught automatically in CI, located precisely when they occur, and actionable for any contributor — not just those with Valgrind expertise.
Currently, TARDIS relies on IPyWidgets for its visualization modules. While effective within Jupyter environments, these widgets have limited compatibility with Sphinx, which is used to build and host the project’s documentation. In contrast, Panel provides significantly better integration with Sphinx, enabling seamless embedding of interactive components directly into static documentation. One of the key advantages of adopting Panel is the ability to deliver fully interactive visualizations within the documentation itself, without requiring a live Jupyter environment. This project aims to migrate TARDIS’s existing visualization tools from IPyWidgets to Panel and make them interactive in the documentation page itself. By doing so, users will be able to explore and interact with widgets directly on the documentation pages, leading to a more intuitive understanding of their functionality and usage. Additionally, this transition will establish a framework to allow future widgets to be easily integrated with interactivity in the documentation. Deliverables: - Custom Abundance Widget migrated to Panel - Grotrian Widget migrated to Panel - All widgets made interactive in the documentation.
The goal of this project is to bring the Maglev REST API server to a production-ready v1.0 state, establishing it as a high-performance, drop-in replacement for the legacy Java-based OneBusAway API. To achieve this, I will implement all missing endpoints to ensure full API parity, eliminate N+1 database queries, introduce robust caching strategies, and build comprehensive test coverage alongside detailed deployment documentation. Furthermore, I will engineer a native Golang GTFS data pipeline—featuring a concurrent transformer and merger—directly into Maglev. This integration will enable zero-downtime hot-swapping of transit data in memory and completely remove the system's dependency on legacy Java preprocessing tools, delivering a fully optimized, tested, and documented backend for transit agencies.
The IfcOpenShell library lacks a stable C API, which currently limits interoperability with other programming languages and makes its higher-level APIs largely accessible only through Python. Its existing WebAssembly support also depends on Pyodide, resulting in unnecessarily bloated binaries, slow initialization, and reduced runtime performance in browsers. This proposal aims to address these architectural limitations by introducing a first-class C API for IfcOpenShell, enabling more maintainable cross-language bindings and a stronger foundation for native WASM builds. The project will replace the current Pyodide-based approach with a direct C++ to WASM build, and will migrate the Python bindings away from SWIG to generated bindings built on top of the new C API. It will establish autogenerated TypeScript bindings and an ergonomic web-facing API, while incrementally moving important high-level Python APIs into the C++ core so that they become available consistently across Python, WASM, and future language bindings.
The current OWASP Snapshot system is passive and requires manual updates, forcing community members to constantly check the website to see what has changed across the organization. This project solves that problem by transforming snapshots into an active, automated digest platform. I will build a system that automatically collects weekly updates expanding the scope to include events, blog posts, and pull requests and delivers them directly to interested users. Contributors will be able to customize their subscriptions, choosing exactly which projects and data types they want to follow. I will also redesign the website's snapshot pages to support date-range filtering, full content display, and social sharing. The core architecture will prioritize GraphQL for all frontend needs. The primary deliverables are the automated processing pipeline, the personalized email newsletter system, subscription management, and the enhanced web interface. A snapshot feedback system and supplementary REST endpoints are planned as stretch goals.
Creating high-quality flashcards from learning materials is time-consuming, which limits wider use of spaced repetition. This project will build an open-source, end-to-end flashcard pipeline for AnkiDroid: a Python system that turns notes, Markdown, and PDFs into Basic flashcards using local open LLMs, plus a lightweight Android importer that fetches those cards over LAN via QR code and adds them into AnkiDroid through its API. Deliverables include the generation UI and pipeline, structured JSON/CSV export and validation, QR-based sharing, the importer app, and tests and documentation.
Peersky users currently lack built-in mechanisms to back up their P2P browsing state (IPFS blocks, Hypercore feeds, chat history, and tab sessions), meaning that reinstalling, machine failure, or going offline results in total data loss and broken communication. This project implements a robust Backup & Restore system that bundles P2P application data into portable .zip archives, supports CID-based distribution via IPFS/Hypercore, and provides cross-browser tab imports via a companion extension. Additionally, it upgrades the browser's PeerChat system with offline resilience, utilizing Hyperswarm’s local UDP multicast discovery to enable seamless messaging on local area networks (LAN) when internet connectivity drops. Key deliverables include: worker-threaded backup/restore daemon; P2P storage integration (Helia); a first-launch tab-import wizard; granular cache management UI; and dynamic LAN-only fallback networking configurations for PeerChat.
Problem Statement In interactive tabletop environments, Game Masters (GMs) face significant cognitive load when managing audio assets during live narration. Manually searching for and triggering specific dramatic recordings often disrupts the immersive flow of the session. There is a need for an automated system that can understand narrative intent and retrieve assets without interrupting the storytelling process.Proposed Solution I plan to bridge the gap between raw audio data and narrative utility by developing an automated pipeline for the TableTalk ecosystem. Leveraging my background in Computer Science and Economics and experience in agentic AI frameworks, I will implement:Narrative Tone Classification: Using a machine learning framework to categorize voice recordings into distinct narrative states (e.g., Urgent, Calm, Fearful).Hybrid Semantic Retrieval: Creating a retrieval engine that combines structured filtering with semantic ranking to allow GMs to use natural-language queries.Real-Time Trigger Logic: Implementing stream-based keyword spotting to map a storyteller's live performance to environmental atmospheric effects like lighting and soundscapes.DeliverablesQuantized Inference Engine: A lightweight model optimized for on-device mobile execution to ensure low-latency narrative classification.Search & Retrieval Module: A high-fidelity interface for natural-language audio discovery.Atmospheric Bridge: A software component that translates identified narrative tones or keywords into external hardware triggers.Technical Documentation: A complete guide and implementation roadmap for integrating these modules into the TableTalk mobile application.This project combines technical machine learning rigor with a deep appreciation for narrative immersion, informed by my previous work in multi-genre game development and algorithmic optimization
Gammapy currently serializes its data products across multiple data formats, which creates a fragmented workflow with poor metadata handling. This project introduces the Advanced Scientific Data Format (ASDF) for Map and Model objects. ASDF is transparent, human-readable, easily extensible, and supports schemas and validation machinery. This project implements ASDF converters and schemas for Gammapy data objects. The resulting ASDF support provides Gammapy users with a unified, self-describing file format that improves reproducibility and simplifies data sharing across the community.
Artemis currently requires all targets to go through the full discovery pipeline even when the HTTP endpoint is already known, lacks deep crawling capabilities, leaves non-CMS technology detection results unused, has no frontend authentication, and is missing detectors for several common vulnerability classes. This project addresses these gaps by enabling direct URL scanning to bypass unnecessary enumeration, replacing the single-page BeautifulSoup crawler with a Katana + uro + gf pipeline for deep crawling, making Wappalyzer's technology detection actionable through intelligent task routing to downstream modules, adding token auto-generation and session-based frontend authentication, and implementing three new vulnerability detectors: SSTI (via TInjA), OS command injection, and NoSQL injection (error-based). All work follows Artemis's existing Karton module conventions with no architectural changes required.
This project aims to improve INT8 inference performance for quantized YOLO26 models on ARM devices using OpenVINO. Currently, several transformation gaps prevent convolution layers from being executed in INT8, forcing fallback to FP16 kernels and increasing latency. Two key issues were identified. First, patterns such as Conv → Multiply → Add → Swish → FakeQuantize prevent convolution post-op fusion. During the optimization pipeline, the Snippets pass collapses this chain into a subgraph before the graph optimizer can fuse Swish and FakeQuantize into the convolution, preventing INT8 execution. Second, activation zero-points represented as Subtract operations are not correctly folded into quantization parameters, which disrupts precision alignment and contributes to FP16 fallback. This project proposes to address these issues by enabling fusion of Swish and FakeQuantize as sequential convolution post-operations and by refining transformation handling of activation zero-points. Additionally, the optimization pipeline will be adjusted to prevent premature subgraph formation for quantized patterns, allowing graph optimizations to correctly fuse operations. The goal is to maximize INT8 convolution coverage on ARM while preserving numerical correctness.
Modern sandboxed applications (like Flatpaks) rely on XDG Desktop Portals for essential OS integration, such as screen sharing, opening files, or sending notifications. Tiling window managers often lack a complete and well-maintained xdg-desktop-portal backend, leaving users with a broken experience for many applications. This project will create a working xdg-desktop-portal backend for the Regolith desktop environment. Regolith is a productivity-focused Ubuntu-based desktop environment that combines tiling window managers (Sway, i3) with GNOME components for system management and GUI features. By using xdg-desktop-portal-luminous as a foundation, this project will deliver native portal implementations for complex features like Background and Clipboard, closing a major functionality gap. A key focus of this project is also on upstream contributions. The work will involve implementing the missing Usb portal in the xdg-desktop-portal-gtk backend and helping define and implement a new ScreenCast API version with audio support. This upstream work will directly benefit the entire Linux desktop ecosystem by providing a standard, secure way to capture application audio, a critical feature for apps like Discord and OBS Studio.
Problem: Drupal users frequently struggle to find specific information across site content, configuration, and documentation because traditional keyword search fails to understand user intent or context. Solution: Develop a decoupled Retrieval-Augmented Generation (RAG) AI assistant. The system will use a Python/FastAPI backend to manage vector embeddings (via databases like Milvus, Pinecone, or ChromaDB) and integrate with a custom Drupal module. This allows users to ask plain-English questions and receive accurate, permission-aware answers grounded in the site's actual data. Deliverables: A Python-based embedding and query API, a custom Drupal module (`ai_knowledge_assistant`) with indexing hooks, an admin configuration interface for managing AI/provider settings, and user-facing chat interfaces (a knowledge block and a dedicated page) that include source citations.
This project is about bringing back the drone-cat-mouse chase exercise in the new RoboticsAcademy architecture. Right now this exercise does not work with Gazebo Harmonic and Aerostack2 which is what all the current drone exercises use. My plan is to set up a Gazebo Harmonic world with two drones — a cat drone that the user programs and a mouse drone that flies autonomously following a 3D pattern. Each drone will have its own full Aerostack2 stack. The mouse drone will run its flight pattern directly through Aerostack2 without HAL.py since its behavior is predefined. The user programs only the cat drone through HAL.py to chase the mouse. Deliverables include the complete Gazebo Harmonic world, dual-drone Aerostack2 setup, the exercise integrated into RoboticsAcademy with the RADI container, documentation, and a reference solution.
The goal of this project is to explore implementing a list-like datatype with enhanced performance. Immutable linked lists are a core datatype in functional programming languages, proving particularly useful in concurrent programs due to the immutability. The most common operations programmers use on an immutable list include random access, sequential accesses, appending, and copy/writes. Unfortunately, sequential access requires a pointer dereference for each node meaning O(n) time which can significantly impact performance. Iteration is necessary for the most popular functions including fold and map and because the datatype is immutable, many changes one may want to make to a list, excluding operations like prepending or removing an element from the head, require allocating a new list which takes O(n) time. This project will design and implement a new immutable linked list datatype with improved performance for the most common operations by leveraging memory/cache locality and mechanical sympathy to improve performance in concurrent programs within the Typelevel ecosystem. The new datatype implements a generalization of the traditional linked list, one where each node contains a constant number of elements rather than one. These nodes, which we call blocks, each contain an array and a pointer to the next block. Deliverables: -Outline direction and priorities for the new datatype based on existing alternatives and how to best integrate in to the greater Typelevel ecosystem (improve performance in concurrent programs by integrating it in to other datatypes ex. Typelevel fs2's Channel) -Research and design the new datatype -Implement the interface for the new datatype -Benchmark and compare theoretical asymptotic bounds against existing immutable linked list-like data structures -Proper documentation and tests
Current LHCb calorimeter reconstruction uses rule-based clustering without exploiting timing or learned representations. The PicoCal upgrade will provide picosecond timing and longitudinal segmentation, creating an opportunity for ML-based reconstruction. I propose a space-time kernel transformer that embeds timing as a physics-informed spatial coordinate for energy reconstruction, benchmarked against the Cellular Automaton and Graph Clustering baselines across four incremental dataset stages. Deliverables include a complete end-to-end pipeline, trained models with timing ablation study, benchmark tables with physics and latency metrics, and a documented open-source PyTorch Geometric codebase for the LHCb group.
SageMath's LazyCombinatorialSpecies framework (sage/rings/lazy_species.py) represents combinatorial species as lazy sequences of symmetric-group actions and supports molecular decompositions, generating series, and structure enumeration. Recent work in PR #41655 adds the Hadamard product, functorial composition, and arithmetic product at the level of molecular data, but these operations lack structure generation. The derivative operation is also missing entirely. This project will: (a) implement the derivative and multisort partial derivatives, with cycle index, generating series, and pointing methods (b) extend the Hadamard product and functorial composition to multisort species (c) systematically verify that weights propagate correctly across all operations (d) implement structures() and isotypes() methods for the derivative, Hadamard product, functorial composition, and (time permitting) the arithmetic product. Every new method will be verified against the existing _test_structures consistency checks. The project concludes with full documentation and a pull request.
In Kubernetes, container termination during security incidents results in the loss of critical forensic data. This project automates the capture of container states by building an event-driven pipeline. Using Falco for detection, a custom Kubernetes Controller for CRIU checkpointing, and checkpointctl for automated analysis, this project extends the capabilities of the existing Medusa framework and ensures that volatile evidence (such as memory, process trees, and open files) is preserved and reported. This enables forensic investigators to perform deep forensic analysis on frozen container states, which otherwise might have been ephemeral.