Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
This project aims to extend the mlr3torch ecosystem by implementing AUC-oriented loss functions and training-time sampling strategies for imbalanced classification. The project will implement efficient Pairwise AUC loss functions (including multiple surrogate variants) and integrate them into mlr3torch via the existing t_loss() interface. In addition, over- and under-sampling strategies will be developed to improve class balance during training. The final outcome will be a well-tested, CRAN-compliant implementation with documentation, enabling users to easily apply AUC-based optimization and improved sampling methods within mlr3 workflows.
This task focuses on bringing binary diffing directly into Cutter by integrating the core capabilities of rz-diff into its interface. Since binary diffing is a common reverse engineering workflow, the goal is to let users select and compare two binaries within Cutter itself rather than relying on external tools. The project would involve building a user-friendly file selection interface for choosing the binaries to compare, then visually presenting detected differences across Cutter’s major analysis views, including the hexadecimal view, disassembly view, graph view, and pseudocode view, so analysts can inspect structural and behavioral changes seamlessly in one environment.
Managing large-scale infrastructures with Uyuni involves monitoring a diverse range of Linux distributions (Debian, Ubuntu, Rocky, Alma, OpenSUSE, others) using Prometheus. While the current stack provides robust data collection via exporters (Node, Blackbox, Postgres, Apache) and visualization through Grafana, system administrators often struggle to interpret raw metrics during critical failures. This project aims to integrate an AI Monitoring Agent into the Uyuni ecosystem. The agent will process real-time metrics from Prometheus and, when an anomaly is detected, perform a deep-dive analysis. By combining metric data with live system inspection via SaltStack (leveraging mgrctl exec calls or the Salt REST API), the AI will generate enriched alerts through AlertManager. These alerts won't just say "High RAM usage"; they will explain the root cause (e.g., a specific memory leak in a process) and provide actionable mitigation steps.
The current approach to request data from the Meshery Server about the relationship between Kubernetes Resources doesn’t scale well due to the need to evaluate through all of the resources every time a request is performed. The proposed solution to this, is to implement a Graph database to store the these resources' relationships to provide faster query responses. I'm going to implement the Graph Database by embedding Cayley (embeddable graph database written in go) into Meshery Server to both efficiently store and retrieve the relationships between the nodes (resources) and hub nodes (cluster, label, annotation, namespace) through the usage of edges (owner_reference, has_label, has_annotation, has_namespace, in_cluster).
eBPF has become the dominant mechanism for extending the Linux kernel at runtime with verifier-enforced correctness guarantees, but those same verifier constraints limit expressiveness, making dynamic string matching, pattern-based rules, and hot-swappable logic difficult to encode directly. Lua, as a lightweight embeddable scripting layer, is well-suited to fill this gap. This project proposes a generalized eBPF integration layer for Lunatik, built around a clear design principle: eBPF provides the verifier-checked kernel hooks (fast path), while Lua implements the dynamic policy logic that the verifier cannot express. Rather than implementing a single binding in isolation, the goal is reusable infrastructure that multiplies the value of all future bindings. Concretely, this project will deliver: luatc — a Lunatik binding for the Linux Traffic Control (TC) subsystem, modeled on luaxdp, eBPF Maps Lua API — a general-purpose interface for eBPF maps within Lunatik, available to all subsystem bindings. luasched — a Lua binding for kernel scheduling hooks via eBPF Examples and documentation for all modules
This project focuses on extending the imputeTestbench R package to better support modern time series data. The current package works well for univariate data, but many real-world datasets are multivariate, where multiple variables evolve together over time and may have structured missing values. The main goal is to add support for multivariate time series while keeping the package simple, stable, and fully compatible with CRAN. The project will introduce methods to handle multivariate inputs, simulate realistic missing data patterns such as block missingness, and improve benchmarking so that imputation methods can be evaluated both per variable and in aggregated form. In addition, the project will improve performance through efficient data handling and optional parallel processing using CRAN-safe approaches. The internal structure of the package will also be refined to improve readability, maintainability, and future extensibility. The expected deliverables include multivariate input support, structured missing data generation, improved benchmarking functions, optional parallel execution, and updated testing and documentation. These improvements will make imputeTestbench more useful for real-world applications such as environmental data, energy systems, finance, and sensor-based monitoring.
Fragmented cultural heritage artifacts — such as Mayan stelae displaced from their original sites — exist today as scattered, incomplete pieces that are nearly impossible to physically reassemble. This project builds an AI-driven virtual reconstruction pipeline for Stela #43 from the Naranjo archaeological site, operating on 3D-scanned .PLY fragment data. The system combines a Point Transformer V2 backbone for geometric feature learning, a Siamese network for fracture surface matching, a Graph Transformer for globally consistent assembly reasoning, and a Trimmed ICP alignment module with pose graph optimization. A synthetic fracture dataset with realistic surface degradation simulation addresses the limited availability of real labeled data. Every learned component has a geometric fallback, and uncertainty quantification ensures low-confidence matches are flagged for human expert review rather than committed automatically. Deliverables include: a modular PyTorch reconstruction pipeline, a reusable synthetic fracture data generation tool, trained model checkpoints, a robust coarse-to-fine alignment module, a global pose optimization module, a full quantitative evaluation report comparing results against the existing geometric baseline, and complete technical documentation. The system is designed to augment archaeologist judgment — not replace it — by pre-screening thousands of potential fragment matches and providing interpretable, auditable match explanations.
The Kubeflow SDK gives AI practitioners a clean Python interface to submit, monitor, and manage distributed training jobs on Kubernetes via TrainerClient. However, LLM-based developer tools currently have no standardized way to access this runtime context — they cannot see a TrainJob's status, stream its logs, or reason about why a job failed. This project extends the existing MCP server MVP (tracked in kubeflow/community#936) for the Kubeflow Trainer SDK. The goal is to deliver a production-ready MCP server that exposes the full TrainJob lifecycle through well-typed, LLM-accessible tools — enabling AI assistants to actively help developers debug, monitor, and operate their Kubeflow training workloads in real time.
This project will extend the tourr R package by adding new projection pursuit indices (PPIs) based on scagnostics, so users can search for a wider range of visually meaningful structures in high-dimensional data. I plan to identify which scagnostic measures are suitable for use as PPIs, implement them in tourr, and test them carefully on simulated datasets where known patterns are hidden among noise variables. I will also compare optimiser strategies, including the jellyfish optimiser, to evaluate which methods recover these structures most effectively and efficiently. The main deliverables will be new scagnostics-based PPIs in tourr, tests written with testthat, examples and vignettes explaining how to use the new functionality, and package-quality documentation and checks to prepare the contribution for practical use and future CRAN submission.
External subtitles are one of the basic and most used features of VLC. VLC already has functionality to allow auto downloading of subtitles. But sometimes these subtitles go out of sync mainly due to frame rate mismatches between the video and subtitle file, different video versions (e.g., Director's Cut), or technical issues like faulty encoding or laggy streaming. This causes subtitles to be consistently early/late or to gradually drift further off-sync over time. Currently vlc doesn’t have any inbuilt auto sync feature. Due to this users have to manually sync (by setting offset and frame drift) or rely on the external program to sync the subtitle. This project aims to solve this issue by using light VAD (Voice Activity Detection) and the lightest whisper model to match subtitles. The main goal would be to make it as efficient as possible so it can even run on mobile devices. Deliverables: 1. Implement a dummy solution using python. 2. Implement native vlc module to match subtitles. 3. Optimize and test the module on various platforms. 4. Update documentation to reflect project contributions.
As GitHub organizations grow, it becomes difficult to understand overall activity across multiple repositories and contributors using the default interface. Important insights such as contributor involvement, repository activity, and development trends are often scattered across many pages, which makes analysis slow and inconvenient. This proposal introduces OrgExplorer, a web-based platform designed to provide a clearer view of activity within GitHub organizations. The project will collect data from the GitHub REST and GraphQL APIs, process it, and present it through an interactive and easy-to-understand interface. The system will include features such as repository and contributor insights, activity visualizations, calculated metrics, and browser-based caching to reduce repeated API requests. Support for GitHub Personal Access Tokens will also be included to enable richer data access. By the end of the project, OrgExplorer will provide an interactive dashboard with organization-level insights, repository and contributor visualizations, metrics and rankings, exportable reports (CSV and PDF), and proper documentation. The goal is to make it easier for users, maintainers, and community members to explore and understand how GitHub organizations are evolving over time.
The Problem: Sugar currently relies on GTK3, which is nearing end-of-life and doesn’t support Wayland properly. This makes it harder to run on modern Linux systems. The Solution: This project focuses on migrating the core "Fructose" activities (Calculate, Log, Chat, Browse, Read, Terminal, etc.) from GTK3 to GTK4. This isn’t just a direct API update — many parts of the UI depend on older X11-based patterns that need to be reworked. I’ll update layouts to Gtk.Box/Gtk.Grid, move input handling to GTK4 event controllers (like Gtk.GestureClick), and migrate system integrations to newer GTK4-compatible libraries such as WebKitGTK 6.0, VTE 3.91, and Evince 4.0. For more complex rendering (like TurtleArt), I plan to use a Cairo bridge with Gtk.Snapshot.append_cairo() instead of rewriting everything from scratch. Deliverables: A working GTK4 port of the supported Fructose activities that runs properly on Wayland. Since the Sugar shell is still evolving, I’ll validate everything locally using my standalone main.py wrapper before integration.
I am applying to build the multipole electrostatics evaluation engine for FFprime, addressing Issue #1 (Electrostatics beyond the atomic charges). FFprime already derives atom-centered multipole moments from quantum-chemical calculations. What it needs is the other half — functions that take those moments and compute the electrostatic potential and field at arbitrary points in space. That is what I will build. My three planned deliverables are: (1) a fully vectorized, convention-unified implementation of monopole, dipole, and quadrupole potential and field functions; (2) a Cartesian-to-spherical conversion layer connecting the Cartesian implementations to the spherical harmonic representation used in the RSC paper; and (3) analysis utilities including field projection and field comparison metrics, as listed in the stretch goal of the issue. Before submitting this proposal I have already made four contributions to the repo: PR #5 implementing dipole and quadrupole functions with 26 unit tests, PR #11 implementing the Cartesian-to-spherical conversion layer, and technical reviews on PRs #2 and #4 identifying vectorization gaps and convention inconsistencies. I am a CS undergraduate at VIT Vellore with strong foundations in linear algebra, NumPy vectorization, and scientific software design. The mathematical framework — tensor decomposition, multipole expansions — is something I have studied independently and already applied in my contributions.
This project focuses on implementing a lightweight real-time gaze cursor overlay that visually represents where the user is looking during a usability test. The goal is to provide an immediate, low-overhead visualization that supports live demos, moderation, and quick qualitative insights.
Standard PCA assumes a globally stationary covariance structure, missing spatial heterogeneity in geographic data. This project implements Geographically Weighted PCA and a suite of geographically weighted matrix decomposition algorithms (RobustGWPCA, GWNMF, GWICA, GWSVD, GWKernelPCA) as first-class citizens in the gwlearn sub-package of PySAL, following Harris, Brunsdon and Charlton (2011) and Harris et al. (2014). Built on libpysal.graph.Graph with a scikit-learn compatible API, the implementation brings Python-native GWPCA: including bandwidth selection, eigenvalue stationarity testing, collinearity diagnostics, and robust multivariate spatial outlier detection, to the scientific Python ecosystem.
Debezium lacks a developer-friendly CLI for managing CDC pipelines. I will build a dbz, a native CLI using Quarkus and Picocli, with two subsystems: a build subsystem that resolves connector dependencies and assembles trimmed OCI images using Jib, and a platform subsystem that wraps the Debezium Platform REST API for full pipeline lifecycle management including sources, destinations, and live log streaming.
LibreHealth Toolkit has no visual way for non-developers to build healthcare forms without writing code. I will build a drag-and-drop form designer using vanilla Web Components and Lit, consisting of a form-designer-canvas, component-palette, properties-panel, and FhirDataBinder. The designer will let users visually assemble FHIR- bound healthcare forms, export/import JSON schemas, and preview forms in real time , all without requiring the end user to write a single line of code.
The project focuses on enabling real-time multilingual accessibility for Eventyay’s live streaming platform by introducing interpreter audio alongside existing YouTube video streams. It includes the development of a browser-based interpreter console that captures audio via WebRTC using a Jitsi-based infrastructure, allowing interpreters to stream translated speech with low latency. On the viewer side, a multi-language audio player will allow users to subscribe to preferred language tracks while maintaining synchronization with the video through automatic and user-adjustable timing offsets. On the backend, interpretation settings such as languages, streams, and synchronization offsets will be integrated into the existing Eventyay admin system and associated with sessions. A lightweight audio pipeline will process interpreter input into scalable HLS streams for reliable delivery. Work also includes ensuring seamless integration with the current platform, maintaining synchronization accuracy, and supporting multiple concurrent language streams. The outcome will be a scalable and user-friendly multilingual streaming experience, enabling organizers to configure interpreter settings, interpreters to operate from a unified browser interface, and viewers to seamlessly select their preferred language during live sessions.
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.