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.
FinBot CTF is OWASP's premier learning environment for agentic AI security, yet it currently operates solely as an offensive arena. Practitioners can exploit vulnerabilities but lack the capability to implement, test, and score defenses against the OWASP Agentic Top 10. This project closes the blue-team loop by introducing a production-inspired, hook-based security framework. The solution is a four-part architecture: (A) a pluggable Guardrail & Detection Framework with pre-tool, post-output, and pre-action hooks that emit a standardized security event model; (B) a Defense-Enabled Challenge Pack converting 3-5 existing offensive challenges (A2: Excessive Agency, A3: Memory Poisoning, A8: System Prompt Leakage) into paired red/blue tracks with integrated defensive scoring; (C) an MCP-Style Scenario Module featuring benign and malicious JSON-RPC tool servers, with detectors for output poisoning, prompt injection via payload, and unauthorized endpoint redirects; and (D) comprehensive Documentation & CI including Docker Compose, contributor guides, and a GitHub Actions test suite. This work transforms FinBot into a complete AI security training platform. Leveraging my prior contributions to the codebase, I will deliver a low-risk, high-impact implementation that equips defenders to build, test, and validate guardrails against real-world agentic threats, solidifying FinBot's role as the practical counterpart to the OWASP Agentic Top 10.
RTEMS Deployment currently supports TAR and RPM package types for toolchain and RTEMS BSP configuration distributions. However, users of Debian-based Linux distributions and FreeBSD must currently use TAR packages, which cannot track dependencies, upgrades, or clean removals like a real package manager. This project will provide native packaging support for Debian (.deb) and FreeBSD (pkg) package types within RTEMS Deployment. A packaging abstraction will be implemented in Python and will be shared between both packaging backends by refactoring the existing RPM backend. This will provide a clean integration with our current deployment model. This will provide RTEMS toolchain installation and management support for developers using Debian, Ubuntu, and FreeBSD distributions with their native package managers. It will also provide integration tests, documentation, and a tutorial for future contributors to easily integrate other package types into RTEMS Deployment.
D4CG's SMART on FHIR application gives patients autonomy over their Electronic Health Records, enabling them to share records with researchers. The current backend supports only Epic's sandbox environment, discards OAuth tokens after exchange, and uses in-memory state management that cannot scale. This project builds a production-ready multi-provider backend that supports Epic, Cerner, and any generic SMART-compliant provider. It replaces the current in-memory architecture with database-backed token persistence, adds enhanced provider search via the ONC Lantern registry, and delivers a tested, documented, and containerized API.
The NeuroHealth-Vision project aims to bridge the "Protocol Gap" in 3D medical AI by developing a standardized evaluation and transfer-learning framework for volumetric foundation models (VFMs). While current generalist models excel in common thoracic or abdominal tasks, they often struggle with specialized clinical protocols involving unique acquisition physics and contrast kinetics. This project will systematically benchmark frontier architectures (like CT-FM, etc.) across various unseen specialty downstream tasks using zero-shot, few-shot, and Parameter-Efficient Fine-Tuning (PEFT) methodologies. Deliverables include open-source preprocessing pipelines for 3D volumetric normalization and spatial alignment, alongside optimized model weights and a comprehensive benchmarking report. This work will ultimately provide the multimodal "perception engine" for the broader NeuroHealth clinical assistant, enabling it to integrate high-dimensional imaging data into its diagnostic reasoning core.
The AI-Powered Guiding Assistant replaces the steep learning curve of manual astrophotography guiding with a predictive, mount specific machine learning model. This project augments KStars' reactive PID controllers by utilizing an offline trained Gated Recurrent Unit (GRU) to automatically learn and counteract complex mechanical errors like gear backlash, harmonic drive signatures, and wind disturbances in real time. To ensure maximum performance on low power embedded devices like the Astroberry, the project features a native C++ inference engine built entirely from scratch using lightweight Eigen3 matrix math. This guarantees highly accurate, intelligent pulse augmentation with an absolute minimal memory footprint and without any big ML dependencies linked into the KStars ecosystem.
Linux Kernel Livepatching is the process of replacing functions in the kernel code affected by CVEs with the patch-applied functions during system runtime. It's basically a method to apply security kernel patches to a running system such as a server without rebooting it. Such a feature is crucial for servers running crucial computational tasks 24/7 which cannot afford a reboot. Livepatch module is already provided by the Linux kernel but it's upto the distributions as to how they will be handled. As of 2026, only a few handful amount of distributions like SUSE, Ubuntu and RedHat offer Linux livepatches, which means no community maintained distribution at the moment offers Linux livepatches. There has been a way to utilise Linux livepatching in Debian in the past using kpatch but after the release of Debian 13 Trixie, the support for the kernel in kpatch has been dropped which halted the progress of supporting livepatching in Debian. klp-build is a promising approach to this problem but it only supports SUSE kernels which are only accessible by internal SUSE employees. Debian also lacks a release plan or mechanism to distribute livepatches for kernels. The goal of this proposal is to introduce Linux livepatching in Debian by studying how livepatches can be integrated into Debian and if existing technologies like clang-extract can be integrated into the workflow, forking klp-build to develop dlp-build which will serve as a tool to create livepatches for Debian kernels, as well as proposing a binary format for livepatches and designing a release cycle for the same.
Mailman 3 has no way to back up or restore a single mailing list. If a list is accidentally deleted or a database migration goes wrong, there is no recovery path. This project builds one: two CLI commands: mailman backup and mailman restore, backed by a schema-validated JSON export format. The backup captures all list state: 85 config fields, member roster across all three roles, header-match rules, aliases, bans, and archiver states. Restore validates the file against a JSON Schema before touching the database, guards against missing domains, preserves verified_on exactly, and uses an is_subscribed() pre-check to avoid SQLAlchemy session poisoning. The operation is silent so no welcome or verification emails are triggered.
This proposal aims to extend the ecotourism R package developed during GSoC 2025 by updating the tourism data to include most of 2025, creating classroom-ready teaching materials, and designing a deployed Shiny app for wildlife exploration across Australia. The project will strengthen the package as both a teaching resource and a practical exploration tool by integrating wildlife occurrence, tourism, and weather data into a more complete and accessible workflow. The proposed work aligns closely with the 2026 project brief: update the package data, develop teaching materials for data science and statistics units, and design, implement, and deploy a Shiny app that helps users learn about the best locations and times to spot wildlife across Australia. The project also builds naturally on my GSoC 2025 contribution to ecotourism, which gives me direct familiarity with the package structure, data sources, and mentor expectations.
The Open Food Facts (OFF) Canada database contains information about branded food products, including their ingredients and nutritional values. This data acts as an integral part for several OFF applications, such as the recipe extension, search page extension, product page extension, and online store extension, which helps in answering user queries about food products. For these applications to respond efficiently, the underlying database must be highly performant and reliable. However, the current database contains inconsistent and incomplete data, which limits its effectiveness for analytics and query performance. The goal of this project is to design and implement an OLAP database by integrating recipe and food product data. This will involve building an ELT pipeline to clean, standardize, and augment the data so that both developers and users can retrieve insights quickly and reliably.
This project proposes the integration of Empirical Dynamic Modeling (EDM) into the Fisheries Integrated Modeling System (FIMS), an open-source framework used for fisheries stock assessment. While FIMS currently supports parametric models such as catch-at-age and surplus production models, ecological systems often exhibit nonlinear dynamics that are difficult to capture with predefined equations. EDM offers a data-driven alternative that reconstructs system dynamics directly from time-series observations using delay embedding techniques. The project will implement core EDM components within FIMS, including delay-embedding generation and prediction algorithms such as Simplex projection, S-map, and Gaussian Process EDM. These methods will be integrated with the existing FIMS statistical inference framework to enable empirical forecasting and hybrid modeling approaches. The final outcome will be a modular EDM module, tested using GoogleTest and testthat, along with documentation and example workflows to demonstrate its application in fisheries modeling.
The current GGUF reader in OpenVINO GenAI manually reconstructs model architectures by parsing metadata and building the OpenVINO model layer by layer — requiring explicit C++ implementations for every supported model topology. This project implements GGUFReaderV2, a new GGUF reader that uses dynamic graph translation instead. It leverages llama.cpp APIs to produce a GGML computation graph (ggml_cgraph), passes it through the existing GgmlOvDecoder and ov::frontend::ggml::FrontEnd infrastructure to produce an ov::Model, and integrates the result into OpenVINO GenAI's read_model() pipeline. A working prototype has already been validated with TinyLlama.gguf — successfully capturing 5,141 OpenVINO operations and executing them through the translation pipeline. Key architectural challenges around tensor naming, capture state safety, and test design have been identified and documented. Deliverables: 1. Functional GGUFReaderV2 class with correct RAII resource management and passing math equivalence tests 2. Stable GGML to OpenVINO graph translation with collision-free node mapping 3. Full integration into GenAI's read_model() API with dynamic shape support 4. Regression test suite validating accuracy across quantization formats (Q4_K, Q6_K, Q8_0) and architectures (TinyLlama, Phi-3, Llama-3, Qwen2.5) 5. Comprehensive documentation and developer guide for extending GGML operator support
The grid library evaluates the Coulomb potential of molecules by numerically solving Poisson's equation. However, true electron densities possess sharp, infinite slope cusps at atomic nuclei. These physical singularities cause the existing numerical Initial Value Problem (IVP) and Boundary Value Problem (BVP) solvers to suffer from catastrophic instability and convergence failures. This project solves this by implementing a "Double-Split-Plus-Solve" architecture. Instead of forcing numerical solvers to handle the singularities, this strategy uses the BFit library and AtomDB to analytically fit and extract the sharp promolecular atomic cores and bulk bonding densities using Gaussians. Because Gaussians have exact analytical potentials, we calculate the potential of the cusps with zero numerical error. This leaves only a tiny, perfectly smooth residual density for grid's numerical BVP solver to integrate, allowing it to converge rapidly and accurately without crashing.
The preCICE website is built on Jekyll with several Ruby gems that have become difficult to maintain (many of which have been abandoned) and cause frequent build failures for contributors. The goal is to move the site to Hugo (a static site generator built on Go), which handles most of what these plugins do out of the box. This means porting layouts from Liquid to Go templates, upgrading from Bootstrap 3.3.7 to Bootstrap 5, and restructuring content to fit Hugo's model. All existing URLs and external documentation integrations will be kept intact during the transition. Deliverables include a fully functional Hugo site, rewritten CI/CD workflows, Algolia search via JSON output, and sub-repo mounts replacing Jekyll submodules. By the end, any contributor should be able to clone the repo and build the site in one command, with no Ruby setup required.
Open Rocket.Chat communities face a growing problem where new accounts join, flood multiple public channels with spam, and disappear before any moderator can respond. Current moderation is entirely reactive and manual, which is simply too slow for coordinated spam campaigns. This project builds a proactive, human-validated anti-spam system that monitors new users during their first 6 to 10 weeks and responds through a graduated restriction system called Moderation Levels, where every action is proportional, reversible, and requires admin approval before anything permanent happens. The system is built as a Rocket.Chat App on the Apps Engine with a seven gate detection pipeline running entirely in memory for speed. Gates catch exact duplicates via hash matching, polymorphic spam via cosine similarity, cross channel floods, rate flooding, rapid room spread, and phishing link campaigns. A four tier Moderation Level system escalates naturally with repeat behavior, from a friendly DM warning through posting cool downs to a permanent block that only lifts when an admin vouches for the user. The admin control layer includes a live dashboard, a full slash command suite, and AI powered on demand summaries so admins have everything they need to make confident moderation decisions without opening a single log file. Deliverables include a fully functional installable Rocket.Chat App covering the complete detection pipeline, a configurable Moderation Level system, a behavioral scoring engine, enriched admin notifications with message history, AI powered user analysis commands, a paginated admin dashboard built for scale, daily scheduled reporting, and complete documentation covering architecture, configuration, and known limitations.
VLC uses lua scripts for tasks like playlist parsing, service discovery, and art fetching. Currently, testing these scripts requires manually running the full VLC application. This is inefficient and fails to catch bugs when external websites change their markup, leaving scripts broken. This project builds a standalone CLI test harness (vlc-lua-mock) that replicates the VLC Lua engine's behavior without requiring a VLC build. It uses mock backends and stubs for VLC Lua bindings, supports both behavior and state assertions, and includes a recording mode for fixtures.
Parallelize Navier-Stokes hypersonic shockwave solver kernels using OpenMP 5.0 target offloading on European supercomputer clusters.
EmbeddedChat is Rocket.Chat's embeddable chat widget, but RC 8.x broke several core endpoints, Matrix federation support is absent, there is no AI extensibility point, mobile responsiveness is inconsistent, and WCAG compliance is incomplete. This project restores RC 8.x compatibility and completes the DDP client migration, adds production-ready Matrix federation via a mode prop backed by an upstream RC core fix, introduces a standalone provider-agnostic AI adapter package, systematically fixes mobile viewport issues, and brings the widget to WCAG 2.1 AA compliance. Working POCs exist for all five goals
Joplin users accumulate hundreds of notes over time, but existing graph plugins only visualize explicit links (:/noteId) and shared tags, leaving semantically related yet unlinked notes disconnected. This project introduces an AI-powered Joplin plugin that uncovers these hidden relationships using text embeddings as the primary mechanism, with optional LLM-based enrichment for labeling and categorization. The default embedding provider is Transformers.js, enabling fully local, zero-setup inference with no external dependencies, while advanced users can opt into Ollama, Google Gemini, OpenAI, or compatible APIs. The system combines explicit links, tag relationships, and embedding-based semantic similarity into a unified graph, ensuring comprehensive note connectivity. The plugin renders this enriched structure as an interactive graph using Cytoscape.js with the fCoSE layout, where node size reflects centrality, node color represents Louvain-detected communities, and edge styles distinguish relationship types (solid for links, dotted for tags, dashed for semantic connections). It includes features such as click-to-navigate, focus mode, filtering, and export to PNG/SVG/JSON. A SQLite-based cache stores embeddings for incremental updates, ensuring scalability and performance, while optional Pass B LLM enrichment adds human-readable relationship labels and categories. The final deliverable is a production-ready .jpl plugin with secure API key handling, provider abstraction, and a comprehensive test suite including deterministic validation of AI outputs.
Apache Fory's compiler can generate type bindings for seven languages, but neither Swift nor Dart have gRPC service generation support. The generate_services() extension point exists in BaseGenerator and is wired into the CLI, but no language implements it yet. This project adds that support for both: Dart will get a new compiler generator (dart.py) covering messages, enums, and unions alongside gRPC stub generation, while Swift will extend the existing SwiftGenerator with generate_services(). Both will emit typed service interfaces and transport bindings using Fory's serialize/deserialize APIs as the codec, covering all four RPC streaming modes with a zero-copy decode path where possible, without introducing any gRPC dependency into the Fory runtimes. Deliverables include the Dart compiler generator, gRPC stubs with golden tests for both languages, runnable server and client examples, cross-language round-trip tests against a Java server, and compiler documentation for the --grpc flag.
ARM-based processors are becoming increasingly common in HPC environments, as in the AWS Graviton, Fujitsu A64FX (one of the world's fastest supercomputers), and various aarch64 nodes at European computing centres. If basf2 can't build on these systems, it's locked out of an excellent infrastructure that the experiment might benefit from. The goal of this project is to explore and evaluate modern, sustainable alternatives to the current Makefile-based approach for externals, ones that can support both x86 and ARM in a unified, maintainable way without duplicating large sections of build logic.
In modern HPC environments, backend services such as SSH certificate management and compute allocation tracking often operate without dedicated, user-friendly interfaces, making them less efficient for administrators and researchers to manage. This project proposes the design and development of web based interfaces within Apache Airavata Custos, including an SSH Signer Admin Portal and an Allocation Management Dashboard. Using Figma for UI/UX design and React with TypeScript for implementation, the system will provide role based access to manage certificates, monitor allocations, track usage, and handle approval workflows effectively.
This project introduces Rust into GNU libcdio, with the goal of modernizing its codebase along with the benefits of Rust's memory safety. This project targets the SCSI MMC library along with a few of the bundled CLI programs to be implemented in Rust. For a start, the MMC library shall be ported to Rust, while keeping the interfaces and symbols same as C. Dependencies on libcdio shall be served through bindings. The CLI programs shall be moved into a separate repository, and implemented in Rust using the clap crate. FFI shall be used to interface with libcdio. The deliverables include a Rust port of the MMC library, along with the cd-read, iso-read, iso-info, mmc-tool commands.
OpenMRS captures every clinical data change via Hibernate Envers, but O3 users must switch to the Legacy UI to view audit logs, creating unnecessary friction. This project builds two native O3 microfrontend packages that surface this data directly in the modern interface. Deliverables include an Audit Log Dashboard on the System Administration page with filterable, paginated audit events and field-level diffs, a Change History tab inside the Patient Chart scoped to the current patient, and a small backend enhancement to openmrs-module-auditlogweb adding entityUuid filtering for efficient patient-specific queries.
RubyGems.org currently lacks transparency into critical package registry events such as gem publications, ownership changes, and deletions, making it difficult to detect supply chain compromises or unauthorized modifications. This project proposes implementing a Merkle tree–based transparency log that records these events in an immutable, append-only structure. The log will provide cryptographically verifiable records that allow maintainers to detect unexpected changes and enable security researchers to audit the Ruby ecosystem.