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.
The project should deliver an AI-enabled backup camera application for AGL using Fluorite. It captures multiple camera feeds via Gstreamer, stitches them into a top-down bird's-eye view, and a YOLOv8 model for object detection. The model should run on TFLite.
This project aims to further develop an open-source intracranial EEG (iEEG) analysis platform by integrating clinically relevant seizure detection and seizure onset zone (SOZ) estimation algorithms, along with enhanced visualization tools. The goal is to support clinicians and researchers through a semi-automated, transparent, and interactive workflow for epilepsy analysis. By combining automated methods with expert input, the platform will facilitate reproducible and interpretable analyses in both clinical and research settings.
This proposal introduces two new inline tracing capabilities for the Metasploit Framework-KerberosTicketTracePresenter and CertificateTracePresenter designed to provide real-time visibility into authentication artifacts during module execution. Currently Metasploit lacks inline inspection for Kerberos tickets and X.509 certificates, forcing operators to export artifacts or switch tools which disrupts workflow and increases operational risk. This project addresses that limitation by integrating structured presenter-based trace output directly into the msfconsole allowing operators to inspect ticket metadata encryption types timestamps certificate fields and cryptographic fingerprints without leaving the session. The design follows the established Metasploit presenter pattern inspired by HttpTrace and krb5_ccache_presenter ensuring consistency modularity and backward compatibility. Trace output is controlled through granular options off, metadata, full, full_censored, csr allowing flexibility based on operational needs. The implementation includes presenter classes dispatcher integration in the Kerberos client mixin, hooks for AS-REQ, TGS-REQ, AP-REQ, and PKINIT flows, along with RSpec test suites and validation in a local Active Directory lab environment. This work has been refined based on mentor feedback and the design reflects improvements discussed during review. The feature significantly improves operator efficiency debugging capability and OPSEC by eliminating disk-based artifact handling and enabling inline visibility into authentication flows across all Kerberos-enabled modules.
Cephalopods display complex behavioral states such as stress, curiosity, aggression, and comfort, but interpreting these states currently depends on expert manual observation and lacks scalable, reproducible tools. This project will build an open source multimodal pipeline that automatically infers and classifies cephalopod behavioral sentiment from video and optional bioacoustic data using computer vision and deep learning. The pipeline will include a dataset ingestion and preprocessing module supporting common video and audio formats, a behavioral feature extractor capturing locomotion, skin pattern dynamics driven by chromatophores, and body posture changes, and a sentiment classification system mapping extracted features to labeled behavioral states. A lightweight deployment API and interactive demo dashboard will make the system accessible to researchers and educators. Key deliverables include dataset ingestion and preprocessing scripts, a multimodal model baseline combining video and optional audio streams, a behavioral feature extraction module for movement and color and posture signals, a sentiment label classifier with training and evaluation scripts, full documentation with reproducible experiments, and a REST API with a demo dashboard for inference. The system will be designed for extensibility across species, datasets, and deployment environments including edge devices.
OWTF right now has a fixed set of plugins. If a security researcher wants to add a new tool or technique, there is no way to do it without touching the core codebase. Plugins also run inside the main OWTF process, which means one bad plugin can crash the whole system. There is no isolation, no sandboxing and no way for the community to contribute plugins. I am planning to fix this by building a simple plugin ecosystem. First, an upload API where users can submit a .py file with metadata. Before saving, a validator checks the code and blocks unsafe things like eval, exec, file writes or socket access. Safe plugins get stored with a pending review status. Second, sandboxed execution. I will run each plugin in an isolated process with limits on CPU, memory, and time and plug this into the existing plugin manager so it works seamlessly. Third, plugin discovery. I will add a /plugins endpoint and a small marketplace UI where users can browse, filter, install and run approved plugins easily. Deliverables: PluginValidator module, SandboxRunner module, UserPlugin database model and migration, upload and listing API endpoints, Plugin Marketplace UI with browse and upload pages, Nuclei plugin as reference implementation, unit and integration tests and a plugin authoring guide.
This project addresses the challenge of distinguishing meaningful security knowledge from noisy or irrelevant changes in OWASP repositories. Currently, large volumes of repository updates include formatting changes, test files, and administrative edits, which dilute the quality of extracted knowledge and reduce the efficiency of downstream systems. To solve this, I propose building a two-stage intelligent filtering pipeline within the OpenCRE Scraper & Indexer framework. The first stage uses regex-based rule filtering to eliminate obvious noise (e.g., non-informative files and structural changes), ensuring low-cost, high-speed preprocessing. The second stage applies LLM-based semantic classification (via models like GPT-4o-mini or Gemini Flash) to determine whether a change introduces genuine security knowledge, such as new vulnerabilities, attack techniques, or mitigation strategies. This hybrid approach balances efficiency with deep contextual understanding. The system will be integrated into the OpenCRE pipeline, forwarding only relevant outputs into a knowledge queue for further processing. It will include structured logging, prompt optimization, cost-efficient API usage, and robust evaluation based on precision, recall, and accuracy. Deliverables include: 1. A production-ready two-stage filtering pipeline (regex + LLM) 2. Integration with the OpenCRE knowledge ingestion workflow 3. A labeled evaluation dataset and performance benchmarks (targeting high accuracy and recall) 4. Unit-tested, scalable, and well-documented codebase 5. Detailed documentation on prompt engineering, system design, and evaluation methodology This project will significantly improve the quality, reliability, and scalability of security knowledge extraction, enabling the OWASP community to focus on high-value insights while reducing noise in the ecosystem.
Rocket.Chat's current message parser uses PeggyJS, which adds bundle size overhead and performance bottlenecks. This project replaces it with a fully hand-written TypeScript recursive-descent parser that produces an identical AST, passes all existing tests, and ships with zero external dependencies. Deliverables include a complete lexer and parser implementation, 100% test suite parity, property-based fuzz testing with fast-check, and a benchmark suite demonstrating measurable performance improvements and reduced bundle size.
This proposal presents a plan to develop hybrid quantum-classical models for classifying dark matter substructure from strong gravitational lensing images, as part of the ML4SCI DeepLense project. The classification task involves three classes: no substructure, CDM subhalo substructure, and vortex substructure from axion/fuzzy dark matter. I propose two complementary approaches: Projected Quantum Kernels (PQK), which encode CNN-extracted image features into quantum states and ompute kernel matrices for SVM classification, and Quantum Convolutional Neural Networks (QCNN), which use parameterized quantum circuits as trainable convolutional filters in a hybrid pipeline. Both methods will be benchmarked against classical baselines on the DeepLense Model I/II/III datasets and evaluated under realistic NISQ noise conditions using depolarizing and devicecalibrated noise models, with error mitigation techniques such as ZNE and PEC. Beyond the standard implementations, I also propose using a GPT-2-based autoregressive Transformer to automatically generate task-optimized quantum circuits for both PQK feature maps and QCNN layers, replacing hand-designed circuit templates. Additional experiments include data-efficiency analysis on small training subsets, hybrid kernel fusion combining classical RBF with PQK, and transfer learning evaluation across different dark matter model datasets.
This project introduces a network abstraction layer to libkboot, enabling boot artifacts to be fetched from remote sources without disrupting the existing loading flow. On top of this abstraction, it implements a minimal, bootloader-focused HTTP/1.1 client and HTTPS support via a TLS-backed transport. This allows kboot to support network-based boot workflows through a clean, maintainable, and extensible interface for future network features.
This project adds LAPACK bindings and JavaScript implementations for singular value decomposition in stdlib, with the main focus on the dgesvd routine (singular value decomposition (SVD) for GE matrices) along with several dependency routines. My plan is to implement the missing LAPACK dependencies in stdlib, port the core routines to stdlib’s ndarray/base API style, for both row-major (C-style) and column-major (Fortran-style) arrays and verify correctness against the Fortran reference implementations. The main deliverable is a working dgesvd implementation, the stretch goal is a working dgesvdq branch. Each routine will also include tests, benchmarks, examples, and documentation so the final result is a working SVD module in stdlib via LAPACK.
I propose two connected workstreams for AOSSIE/Stability Nexus. First, I will implement composable derivative oracles for OrbOracle on EVM: a ComposedOracle contract (multiply/divide/invert using existing feeds), safe scaling/rounding, staleness handling, and a factory-based deployment/validation flow (including dependency checks). I will also extend the OrbOracle Explorer frontend so operators can create composed feeds, inspect dependencies, and monitor feed health. Deliverables include contract code, tests (unit/integration/fuzz), UI updates, and documentation for integrators. Second, I will build and improve static landing pages for selected user-facing projects with strong SEO and reliable CI checks (build, links, quality basics). Each project will keep its own brand identity while improving consistency in quality and maintainability. Deliverables include deployed pages, content workflow improvements, and CI/deployment documentation. Overall outcome: reusable oracle infrastructure plus better public project surfaces.
JSON Schema defines 18 format types (uri, email, date-time, ipv4, etc.) but the official test suite has minimal coverage for most of them. Without shared test cases derived from the actual RFC grammars, implementations diverge silently - ajv-formats accepts space-separated date-times, python-jsonschema reduces email validation to checking for "@", and no one can tell which behavior is correct. This project builds a comprehensive, RFC-grounded test suite for all 18 formats. Every test case is derived directly from the ABNF production rules in the governing RFC, verified against at least two implementations, and documented with a direct RFC citation. Pre-proposal research across 10 formats has already produced 11 filed issues across ajv-formats, sourcemeta/core, libidn2, and golang/go. Deliverables: 200-280 test cases structured as PRs to the JSON Schema Test Suite repository, covering all 18 formats in JSON Schema 2020-12, with Bowtie integration as a stretch goal.
Publicly available Greek datasets like those on OpenGov are a goldmine of information but they often contain personal details that need to be hidden to comply with privacy laws like the GDPR. Doing this automatically for Greek text is tough because the language is highly inflected and the documents are usually full of OCR scanning errors. To tackle this I am proposing a standalone ML assisted anonymization tool that plugs right into the glossAPI pipeline. Instead of a heavy slow model I am using a lightweight hybrid approach. It uses fast regular expressions and custom dictionaries to catch standard info and fix OCR typos while leaning on Microsoft Presidio and the spaCy multilingual pipeline to smartly detect complex entities like names and organizations. By wrapping this engine in a simple FastAPI REST interface we keep the main glossAPI codebase clean and independent. By the end of the project I will deliver this fully functional privacy API the necessary code to link it to glossAPI and clear practical documentation so future maintainers can easily protect sensitive public data.
Liquid Galaxy RPG is a multiplayer 2D fantasy action game built for the Liquid Galaxy multi-screen display system, where a continuous tile-based world spans all LG screens simultaneously. Four players join via a Flutter mobile controller app, competing in King of the Hill (2v2 PvP castle capture) or cooperating in Dragon Raid (4-player boss fight with wave-based enemies). The game is built on Phaser 3 served via Node.js WebSocket — each LG screen opens one URL in Chromium on Ubuntu 16.04 rig. A unique AI Cheerleader powered by the Gemini API runs on each player's phone, delivering private personalized motivational messages via Flutter TTS based on live game events.
Pwndbg’s codebase is incosistent and (only partially) structured. The goal of the project, is to "clean" the codebase, by enforcing stricter linting, refactoring code, splitting large files/modules into smaller parts, and adding standardized logging and wrappers. Deliverables: cleaner structure, improved readability, reusable utilities, and documented conventions
The Medical Informatics Platform (MIP) currently lacks standardized automated governance for its federated infrastructure, leading to deployment friction and configuration drift. I plan to solve this by implementing a vendor-neutral CI/CD pipeline in GitHub Actions that automates Infrastructure-as-Code (IaC) validation and maturity assessment using the OWASP DSOMM framework. Key deliverables include a detailed DSOMM based infrastructure audit, an automated orchestration pipeline featuring IaC scanning and SBOM generation, and a reusable secure pipeline blueprint to enable scalable and reliable infrastructure management across the EBRAINS community.
My goal is to fix this by implementing mgrctl get a simple, kubectl-style interface for querying Uyuni resources. Think mgrctl get systems, mgrctl get errata --cve CVE-2026-1234, or mgrctl get jobs --state failed. Everything goes through the existing Uyuni REST API, so there's no new authentication logic to worry about, and the output can be a clean table, JSON, or YAML depending on what you need. By the end of the program I plan to have full coverage across five namespaces like systems, system groups, channels, scheduled jobs, and errata , with filters, structured output, and a mock-based test suite that doesn't need a live Uyuni instance to run. If time allows, I'd also like to add mgrctl describe for richer single-resource views and shell completion for bash and zsh.
New openSUSE users face a steep learning curve navigating distribution-specific tools like zypper, YaST, Btrfs/Snapper, and systemd. This project builds a locally-running AI onboarding assistant that pairs a Small Language Model (SLM) with a Retrieval-Augmented Generation (RAG) pipeline over official openSUSE documentation. The assistant detects the user's actual system context (desktop environment, pending updates, failed services, filesystem layout) and grounds every answer in real documentation and real system signals. It runs fully offline after setup, respecting user privacy. A working proof of concept already exists with local SLM inference (TinyLlama 1.1B via llama-cpp-python), a ChromaDB-backed RAG pipeline, system context detection, CLI and Web UI interfaces, and a benchmarking framework. Deliverables: (1) production-ready SLM with tiered model support, (2) enhanced RAG pipeline with 4+ documentation sources and tuned retrieval, (3) expanded system context detection covering Btrfs/Snapper, networking, GPU, and locale, (4) jeos-firstboot module for first-boot integration, (5) systemd service with socket activation, (6) RPM packaging via OBS with subpackages for core, docs, and model, (7) security hardening and prompt injection defenses, (8) comprehensive testing across hardware tiers, and (9) blog posts and user documentation.
ImageLab is a block-based image processing tool built with Blockly and OpenCV . It helps students learn image processing by building pipelines with visual blocks. Problem statement: This project has the following key issues: This project will implement "Interactive Learning Mode" transforming ImageLab into a transparent, collaborative, and scalable learning ecosystem. First, per-step processing that returns intermediate image outputs after every operator, displayed in a scrollable filmstrip timeline so students can see the output after each step and what each step is contributing for the final output. Second, an image analysis panel showing RGB histograms and metadata for any selected step. Third, pipeline persistence allowing students to save, load, version, and share pipelines using secure share tokens. Fourth, a batch processing engine to run one pipeline across multiple images concurrently with progress tracking and ZIP download. Fifth, custom composite operators (macros) that let students save reusable block sub-chains into the Blockly toolbox. Deliverables: A production-ready fully tested interactive step viewer, image analysis panel with Canvas-based histogram renderer, SQLModel backed pipeline persistence with HMAC share tokens, asyncio batch processing engine, and a macro system with DAG validation and Blockly toolbox injection.
This project aims to improve the quality, consistency, and usability of the Checkstyle documentation website by enhancing automation and user experience. Although documentation generation has been partially automated from Java sources, gaps still exist such as missing examples, inconsistent formatting, and difficulty in navigation. The project will focus on completing and standardizing documentation for all Checkstyle modules by adding missing examples and enforcing uniform formats through automated validation integrated into the build and CI pipeline. This will reduce manual effort and ensure documentation remains accurate and up-to-date. Additionally, the website’s usability will be improved through frontend enhancements, including a client-side search feature based on a pre-generated index, enabling fast and backend-free navigation across the static site. Existing user-reported issues will also be addressed to further enhance the overall experience. Deliverables include: 1. Adding missing examples for all Checkstyle modules and checks 2. Standardizing and validating documentation formats across the website 3. Automating documentation checks within the CI/build pipeline 4. Implementing a client-side search feature for improved navigation 5. Resolving existing website usability issues and improving UX 6. Providing clear documentation for contributors on maintaining content
This project aims to implement a high-performance Apache Arrow backend for PODIO. Currently, PODIO data is primarily persistent in ROOT and SIO formats, which can introduce significant I/O overhead for modern, language-independent analytics. The Problem In high-energy physics, data analysis often requires processing only specific subsets of complex event structures. Traditional file-based backends often require loading entire object hierarchies, leading to memory and I/O bottlenecks. The Solution The proposed solution implements a dual-path ingestion strategy within PODIO's code generation engine In-Memory Zero-Copy Access: Utilizing arrow::ListView to map existing PODIO memory buffers directly into Arrow tables for real-time, language-independent analysis. Serialized Normalization: Implementing a normalization layer that packs scattered memory blocks into contiguous arrow::ListArray structures to satisfy the strict requirements of Parquet storage. Relational Mapping: Resolving C++ pointers into a Composite Key (Collection ID + Index) to maintain complex object relationships across different platforms and memory layouts. Key Deliverables Core Arrow Backend: A C++ implementation integrated into PODIO's generator to translate YAML-defined models into Arrow’s columnar format. Parquet Support: Out-of-the-box serialization to industry-standard Parquet files. Round-Trip Validation: A robust testing suite ensuring 100% data parity when converting between PODIO Frames and Arrow Tables. Performance Benchmarking: A side-by-side comparison of throughput and disk footprints between ROOT TTree and the new Arrow/Parquet backend.
Neural weather prediction models like neural-lam rely on graph neural networks, but the current graph construction pipeline is locked to rectangular grids — blocking support for irregular data sources like weather stations, satellite swaths, and icosahedral model grids (ICON, MPAS). This project replaces the hardcoded pipeline with a flexible, topology-agnostic architecture spanning two repositories (weather-model-graphs and neural-lam). The core work delivers three things: (1) a two-step mesh architecture that decouples node placement from connectivity, enabling any layout (triangular, prebuilt, density-adaptive) to combine with any connectivity mode; (2) a bridge layer that eliminates 600+ lines of duplicated code by making neural-lam call weather-model-graphs directly, validated through a shared schema contract; and (3) migration to PyTorch Geometric's HeteroData for type-safe, self-documenting graph representation. As stretch goals, the project introduces a graph quality metrics framework for comparing mesh topologies without training, density-adaptive meshing driven by data or prediction error, and spherical coordinate support to fix systematic distortion at high latitudes. I have already contributed the foundational PRs (#81, #91, #92, #123, #258) and authored the two strategic issues (#384, #385) that define this project's architecture.
This project aims to introduce a robust and high performance block editor and a proper markdown parser to Marknote. Right now, the editor is hard to maintain, full of many condition checks, and has bugs and limitations, especially when handling formatting and advanced features. My plan is to use md4qt to parse Markdown into a structured format and build a block editor that supports things like lists, tables, code blocks, and drag-and-drop. I will design the system so parsing, rendering, editing, and saving are cleanly separated, which will make the app faster, more stable, and easier to extend in the future. I will implement this step by step, making sure all features like undo/redo and export continue to work, and I will test everything properly to ensure a smooth user experience.
pyGAM currently produces anti-conservative p-values for smooth terms due to several deviations from the statistical theory outlined in Wood (2013b). In particular, it assumes a simple chi-squared reference distribution, ignores effective degrees of freedom corrections, and does not properly handle penalization-induced rank deficiency. This project will correct the statistical inference pipeline in pyGAM by implementing five key fixes: (1) proper computation of effective degrees of freedom, (2) stable pseudoinverse truncation, (3) replacement of the chi-squared approximation with a weighted mixture using the Liu-Tang-Zhang method, (4) QR-based covariance handling, and (5) correct treatment of unknown-scale families. The result will be a refactored inference module that produces well-calibrated p-values, along with a comprehensive validation suite comparing type-I error and power against mgcv. Stretch goals include incorporating smoothing parameter uncertainty corrections and exploring REML-based smoothing. Deliverables include a refactored statistics() pipeline, extensive tests, and improved documentation.