Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters
13453 Projects Found
Sort by

3.1. Improve acceptance test infrastructure

intermediate
Oppia Foundation•2026Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
175h (Medium)

This project aims to improve Oppia’s acceptance test infrastructure by migrating existing tests from Puppeteer to Playwright to enhance stability, maintainability, and developer experience. The migration will be performed incrementally with dual-framework support to ensure CI stability. In addition, the project will address test flakiness by identifying and fixing persistent flaky tests, improving debugging workflows, and enhancing snapshot handling. The project also includes adding safeguards such as lint checks to prevent conflicts in shared utilities during migration. The expected outcome is a robust, maintainable, and reliable acceptance testing system with reduced flakiness and improved developer productivity

pythonjavascriptangularjs+10
Student: Mohak Gautam
Code
Proposal

TechDraw UX Overhaul

intermediate
FreeCAD•2026Varies175h (Medium)

This project will primarily change the command system for TechDraw from a pre-selection to a post-selection. So that the user can click on a command and then the feature they want to annotate. Additionally visual guidance will be added for these commands so it is natural the new post-selection. The tools that cannot be changed to post-selection will instead be grayed-out if the user has not picked a correct feature. Also the toolbars will be changed.

pythonc++qt+2
Student: Morten Vajhøj
Code
Proposal

Empowering OpenSCAD with Local Agentic AI Assistance

intermediate
BRL-CAD•2026Varies175h (Medium)

This proposal introduces an optional, privacy-first AI assistant for OpenSCAD to flatten the learning curve of SCAD syntax and geometric transformations. Integrated as a togglable dock panel, the assistant remains completely inert when closed and requires no cloud subscriptions or external API keys, instead leveraging locally running models via Ollama or any OpenAI-compatible server. Beyond standard Q&A, the project implements agentic behavior where the AI can analyze the active script, propose modifications through an inline diff, and apply approved changes directly to the editor as undoable actions that trigger an automatic preview. The architecture is designed to be vision-model-ready from the start, ensuring future viewport context integration requires no structural refactoring. This creates a transparent, local-only loop that empowers users without compromising the project’s core philosophy of user-controlled development.

pythonc/c++opengl+6
Student: Bidyendu
Code
Proposal

Implement lossless JPG transformations in the Commons Android App

intermediate
Wikimedia Foundation•2026Varies175h (Medium)

This project is proposed to 1. Prevent the loss in details happening when the user edits, uses the crop/rotate feature when uploading images through the Wikimedia Commons app by replacing LLJTran with JPEGTran which handles details gracefully. 2. Implement Lossless Block-Level Blur The Blur feature at present makes quality loss of image in the process. This is solved by recompression to only relevant blur required pixel blocks then untouched areas wont have loss in details. 3. Auto-detect and blur faces & car number plates. When the user uploads images there is less privacy for random people and car number plates captured by user in the photo use OpenCV to detect faces/plates and apply blur to only region which OpenCV specifies

javascripthtmlphp+7
Student: Rishan
Code

Platform Scalability and Security

intermediate
Kubeflow•2026$3k–$6.6k175h (Medium)

Kubeflow's adoption at enterprise scale exposes critical bottlenecks in controller efficiency, security posture, and operational overhead. This project delivers six required improvements: (1) ConfigMap-driven database garbage collection for KFP pipeline runs, mirroring the existing artifact_retention_time pattern; (2) ScheduledWorkflow controller migration from legacy client-go informers to controller-runtime; (3) zero-trust NetworkPolicy enforcement for training job namespaces; (4) cross-namespace artifact security hardening with integration tests; (5) KFP dead code removal of deprecated manifests; and (6) Pod Security Standards compliance with CI regression gates. Stretch goals include Gateway API migration, Spark webhook readiness probes, and a Metacontroller migration design doc. This work builds on 12 pre-GSoC contributions (5 merged, 7 open) across 5 Kubeflow repositories.

pythontensorflowkubernetes+5
Student: siddhant_jainn
Code
Proposal

Machine Learning Interatomic Potentials (MLIP) in DeepChem using E(3)-Equivariant Neural Networks

advanced
DeepChem•2026Varies350h (Large)

This project aims to develop a native PyTorch-based Machine Learning Interatomic Potential (MLIP) framework within DeepChem, enabling efficient prediction of molecular energies and forces without relying on external frameworks. MLIPs approximate the potential energy surface of molecular systems, providing a scalable alternative to Density Functional Theory (DFT) for molecular simulations. The project will implement a modular, production-ready framework supporting E(3)-equivariant architectures such as NequIP and MACE, fully integrated with DeepChem’s TorchModel API, graph-based data pipelines, and equivariance utilities. Key deliverables include a generalized MLIPModel abstraction, efficient graph construction and batching pipelines, a stable joint energy–force training system, and comprehensive benchmarking on MD17 and QM9 datasets, including molecular dynamics stability validation. The final outcome will be a fully integrated and extensible MLIP module within DeepChem, enabling end-to-end molecular simulation workflows.

pythonnumpypytorch+1
Student: Satvik Mittal
Code

PictoPy: Expanding into Semantic Intelligence, Memories, Video, and Secure Sharing

advanced
AOSSIE•2026Varies350h (Large)

This proposal aims to implement intelligent event classification, natural language search, and EXIF metadata read-write capabilities for image metadata portability. Key backend upgrades include implementing image metadata based image clustering with SigLIP2 for visual similarity-driven clustering. It introduces application optimization techniques like modular AI model management, allowing users to extend functionality on demand without bloating the base install, to keep the core application lightweight. It improves face clustering accuracy by addressing confirmed gaps in the current DBSCAN pipeline, including adaptive eps estimation and a face quality gate. On the frontend side, a new Memories UI will be introduced with advanced sorting features, user notifications, video support, along with a new landing page for the product launch. A major addition is shareable album links: users will be able to generate secure, token-based links to share selected photos over the network while the PictoPy backend is running, with new API endpoints serving image data directly to a lightweight web-based receiver. Additionally, comprehensive documentation—including contributing guides, API references, and setup videos—will encourage new developers to contribute. These improvements will make PictoPy more user-friendly, scalable, and ready for widespread adoption.

pythonjavascriptswift+8
Student: rohan-pandeyy
Code

Physical AI Inference & Trajectory Upscaling for ros2_control

intermediate
Open Robotics•2026Varies175h (Medium)

AI policies (VLAs, Diffusion Policy) output joint targets at 20–50 Hz, while robot hardware requires continuous commands at 500–2000 Hz. Naively forwarding sparse waypoints causes velocity discontinuities and acceleration spikes that trigger hardware faults or physical damage. Existing solutions are batch-oriented and cannot handle streaming, jittery AI output. This project builds a dedicated Inference-to-Control Bridge in ros2_controllers. It ingests streaming AI waypoints via topics and upscales them to hardware rate using C²-continuous quintic spline transitions, solving the transition problem. A lock-free look-ahead buffer absorbs inference jitter, a time-scaling mechanism handles buffer underrun gracefully, and a safety monitor enforces velocity, acceleration, and jerk limits via time dilation before every hardware dispatch. Deliverables: inference_bridge_controller plugin, quintic spline primitives in control_toolbox, full C++ test suite, and a Gazebo end-to-end demonstration on a simulated 6-DOF arm.

pythonc/c++ros+5
Student: Vedhas Talnikar
Code
Proposal

Python Bindings and Real Time 3D Visualization for OpenTRIM

advanced
Open Technologies Alliance - GFOSS•2026$6k–$13.2k350h (Large)

OpenTRIM is a C++/Qt Monte Carlo ion transport simulator for radiation damage research. Every parameter study today requires four manual steps: edit config.json, invoke the CLI, load HDF5 output, and plot by hand. No Python interface exists. No live view inside the target. This project delivers both. Feature A - Python Bindings: A pybind11 module wrapping libopentrim so researchers drive simulations directly from Python: result = opentrim.run(config_dict). Tally data is exposed as zero-copy NumPy arrays via ArrayNDd buffer protocol. result.to_xarray() returns a labeled Dataset with element names and nm coordinates for publication-ready depth profiles in one line. result.core exposes mccore internals - ion counts, per-tally SEM, and run merging. GSoC 2025 user_tally binning is bridged to Python. Seven benchmark configurations verify physics parity with the CLI. Feature B - Real-Time 3D Visualization: A QOpenGLWidget tab rendering live ion tracks as GL_LINES during simulation. A two-buffer pipeline handles 30M events/second without stalling. Cascade genealogy is color-coded from ion.recoil_id(): beam ions blue, PKAs orange, sub-cascade recoils red. A SEM convergence overlay tells researchers when to stop. Camera state serializes to JSON; --render produces headless PNG with no display server. Both features are isolated - bindings/ and source/gui/trackview.* - delivered across 14 pull requests in 350 hours.

pythonmysqljava+7
Student: DHANAVANTHESH S
Code

Quality Check ToolBox V1.0

intermediate
Open Science Initiative for Perfusion Imaging•2026Varies175h (Medium)

Problem: There is currently no standalone, open source Python library within the OSIPI ecosystem for post-processing quality control (QC) of Arterial Spin Labeling (ASL) MRI perfusion data. Existing solutions are either MATLAB dependent, closed-source or tightly coupled to specific preprocessing pipelines, making scalable and reproducible QC difficult for clinical and research datasets. Solution: I will build Quality Check ToolBox V1.0 for osipy a pipeline-agnostic, modular Python library that evaluates ASL-derived Cerebral Blood Flow (CBF) maps and generates interpretable PASS/WARN/FAIL triage metrics. Using a configurable registry architecture, it evaluates the Quality Evaluation Index (QEI) alongside orthogonal checks for BIDS compliance, M0 calibration and motion. It features graceful degradation and population-specific YAML configurations (e.g., pediatric, stroke) to successfully distinguish real pathological signals from acquisition artifacts. Deliverables: Core osipy-integrated QC pipeline with a @register_qc_check module registry. Full implementation of the Dolui et al. 2024 QEI metric. Fallback-capable modules for control-label validation, M0 saturation, and motion tracking (FWD/DVARS). Configurable PASS/WARN/FAIL verdict logic that prevents pipeline crashes on missing data. A comprehensive Pytest suite and MkDocs documentation. A standalone HTML visual dashboard for reviewing QC metrics across cohorts.

pythongithub
Student: Agnik Misra
Code
Proposal

Archiving Voided Data

advanced
OpenMRS•2026Varies350h (Large)

In OpenMRS, "voiding" soft-deletes records, causing tables especially immutable ones like Observations (obs) to accumulate massive amounts of inactive data over time. This unbounded growth degrades system performance and complicates database maintenance. This project implements a "Real-Time Archival Trigger" to maintain lean primary tables. When a record is voided, a Hibernate interceptor will execute an atomic transaction to immediately copy the data to a dedicated obs_archive table and hard-delete it from the active table. To manage the infinite growth of the archive, a scheduled background JobRunr task will permanently purge expired records by dropping old partitions from the archive table based on configurable retention policies (e.g., after 7 years).

javahtml5groovy+11
Student: Shivvani Ramadugu
Code
Proposal

Scaling the Meshery Ecosystem

advanced
Meshery•2026Varies350h (Large)

The Meshery ecosystem's web properties need ongoing frontend modernisation and backend reliability work as they scale. I will deliver performance-optimised UI components, mobile-first responsive fixes, new dynamic sections for the extension ecosystem, and systematic infrastructure improvements, all backed by clear documentation. This builds directly on contributions I have been making since December 2025.

javascriptgolangkubernetes+2
Student: Khusham Bansal
Code
Proposal

Apache Beam Add Kafka Streams Runner

intermediate
Apache Software Foundation•2026Varies175h (Medium)

This project will build a portable Kafka Streams runner for Apache Beam so that Beam pipelines can run on Kafka Streams using the Beam Fn API. The runner will translate portable Beam pipeline protos into Kafka Streams topologies and support a working skeleton for core transforms: Read, stateless ParDo, GroupByKey, Combine, non-merging windowing, and Flatten. The implementation will focus on correct watermark propagation, commit-based bundle boundaries, exactly-once semantics, and integration with the existing Beam portability stack. Deliverables include a new runners/kafka-streams module, runner entry points, a pipeline translator with transform-specific translators, watermark and bundle management, tests using TopologyTestDriver and real Kafka-based integration coverage, and documentation for the Beam community.

pythonjavascriptjava+7
Student: Muhammad Junaid Shaukat
Code
Proposal

Graphical interoperability between CyberEther and GNU Radio (OOT module).

advanced
GNU Radio•2026Varies350h (Large)

This project aims to create OOT module, that uses CyberEther's GPU-accelerated framework which uses low-level graphics APIs to create high-performance sinks to visualize GNU Radio data streams in a normal GRC workflow. current implementations of these sinks rely on `gr-qtgui` which is fine but it would be a better to have the option of choosing CyberEther sinks which would be more optimized for maximum throughput and low latency along with a modern design. Main challenges are: minimizing data movement from the GR scheduler to CyberEther tensors, as in high sampling rates unnecessary copying would be expensive and undermine whole native performance edge. Also, CyberEther's current public plotting path internally manages a shared runtime built around `Jetstream::Instance`, and a normal GNU Radio flowgraph can have multiple sinks which would be tricky to manage safely. My core implementation target is a robust first sink family around lineplot and waterfall, with spectrogram support in the second half of the project if the lower-level CyberEther path is needed. These challenges(and other) can be resolved by architecting new solutions which borrow from past implementations namely `gr-cuda` for custom buffers, `gr-cyber` (an earlier prototype from Luigi, the creator of CyberEther) and `gr-fosphor` for relevant challenges.

pythonc++dsp+6
Student: itsYoussef
Code

Implementing ANY_VALUE() and GROUPING() in MariaDB

advanced
MariaDB•2026Varies350h (Large)

This project aims to implement the ANY_VALUE() and GROUPING() functions in MariaDB, addressing longstanding gaps in compatibility with MySQL 8.0 and modern SQL standards. Currently, the absence of these functions limits MariaDB’s usability in applications that rely on advanced GROUP BY semantics, particularly when migrating from MySQL or working with rollup queries. To solve this, I will extend MariaDB’s SQL parser and execution engine to support both functions. For ANY_VALUE(), I will implement a new aggregate function that allows safe selection of non-aggregated columns under ONLY_FULL_GROUP_BY. For GROUPING(), I will introduce a function that distinguishes between NULL values originating from rollup aggregation and those present in the underlying data, by tracking rollup state during query execution. The primary deliverables of this project include fully functional implementations of ANY_VALUE() and GROUPING() in MariaDB, comprehensive MTR test suites validating correctness and MySQL compatibility, and updated documentation describing their usage and behavior. The final outcome will improve MariaDB’s standards compliance and provide developers with essential tools for writing expressive and portable SQL queries.

cmysqlmariadb+7
Student: Jaeheon Shim
Code
Proposal

Physics-Informed Neural Network Shape Optimization

advanced
Machine Learning for Science (ML4SCI)•2026Varies350h (Large)

Vanilla MLP PINNs suffer from spectral bias and slow convergence, which directly limits the quality of shapes produced by PINN-based shape optimizers. This project integrates Physics-Informed Gaussians (PIG) into the coordinate projection shape optimization framework of Zhang et al. (2024), replacing the MLP physics solver with learnable Gaussian basis functions that adaptively concentrate resolution in high-residual regions. I will build a PyTorch framework with swappable MLP, PIXEL, and PIG physics backends, validate all three on the published iron core torque optimization benchmark, and finally, apply the best-performing backend to a novel use case: optimizing Paul trap electrode geometries to maximize the geometric efficiency factor governing ion confinement. I will explore the open-source framework with backend comparison results and a working Paul trap shape optimizer with fabrication constraints.

pythonmachine learningc+++2
Student: George Liao
Code

Remove the Build Hook Mechanism, Store Extensions

intermediate
NixOS Foundation•2026Varies175h (Medium)

The Nix build hook mechanism has been marked for removal since 2017, but it still fills an important gap in Nix's distributed build architecture. In particular, it is currently the only interface that can pass a build request together with its full set of input paths atomically. Store-based remote building does not provide this: it splits the process into separate calls, which makes it difficult for builder stores that schedule builds across a cluster, such as "nix-scheduler-hook", to know where inputs need to be copied before the build is assigned. This project proposes a cleaner, more extensible replacement by adding a new virtual "buildDerivation" method to the "Store" base class. This method would bundle the derivation path, derivation, and input paths into a single call, preserving the atomic behavior that cluster schedulers rely on. To ensure compatibility, the new interface would include a default implementation so that existing store backends continue to work unchanged. The project will validate this design through an end-to-end proof of concept by adapting "nix-scheduler-hook" to use the new API. Once the new mechanism is confirmed to support distributed scheduling correctly, the legacy build hook mechanism can be removed from the Nix daemon. Expected deliverables include the new virtual "Store" method and its default implementation, full removal of the build hook mechanism from the Nix daemon, a proof-of-concept "nix-scheduler-hook" adaptation, a passing distributed build test suite, and accompanying API documentation and migration guidance.

gitnix
Student: Amrit Amber
Code
Proposal

JBoss Web Server Diagnostic Configuration Validation Toolkit

intermediate
JBoss Community•2026Varies175h (Medium)

This project proposes building jws diag, a read only diagnostic CLI for JBoss Web Server that helps operators and SREs to inspect runtime and configuration state more easily. The tool will provide concise installation and deployment summaries, effective connector TLS and proxy configuration reporting, validation checks for common misconfigurations, structured JSON output, and realistic test coverage for troubleshooting and automation use cases.

androidjavaide+12
Student: Milan P Samuel
Code
Proposal

Parallelizing r.proj and Raster Processing Modules in GRASS

advanced
NumFOCUS•2026Varies350h (Large)

r.proj and r.param.scale are widely used GRASS raster modules that run entirely on a single core, leaving modern multi-core hardware idle. This project parallelizes both using OpenMP. For r.proj, the core blocker is the legacy readcell tile cache which is not thread-safe. The solution is a two-path architecture: a fast RAM-resident buffer for maps that fit in memory, and a thread-local tile cache fallback for larger maps. For r.param.scale, a sequential sliding buffer blocks row-level parallelism. The fix is the same RAM preload pattern: load the full raster before the parallel region and let threads work on rows independently. Proof of concept PRs show 2.5x speedup for r.proj and 1.7x speedup for r.param.scale on 100M cell rasters. r.geomorphon will be audited during the bonding period as a third target. Deliverables include production-quality parallel implementations of both modules, per-thread PJ_CONTEXT initialization, a fix for issue #5776, pixel parity regression tests, scalability benchmarks, and full documentation.

pythonjavascriptr+3
Student: Kaushik Raja
Code
Proposal

Enabling Differentiable Rendering via AD of Parallel C++ STL Primitives in Clad

advanced
CERN-HSF•2026$6k–$13.2k350h (Large)

This project proposes to enhance Clad, a Clang-based automatic differentiation (AD) tool, by leveraging its liveness analysis to automatically generate lock-free backward passes for highly parallel differentiable rendering pipelines. Specifically, the project targets the atomic bottleneck inherent in 3D Gaussian Splatting (3DGS) rasterization. Modern GPU-based differentiable renderers suffer from heavy use of atomic operations (e.g., atomicAdd) during the backward pass because many threads attempt to update the same pixel and gradient buffers simultaneously. This contention overwhelms L2 cache atomic units, stalling execution and causing the gradient computation to consume a significant portion of training time. My approach is twofold. First, I will redesign the rendering pipeline to avoid write conflicts by construction using deterministic sorting, tile-based memory ownership, and local accumulation before a single global write. Crucially, I plan to build this new architecture on top of my previous GSoC work that integrated the Thrust API into Clad. By utilizing Thrust's highly optimized parallel primitives (such as thrust::sort_by_key and thrust::reduce) for the sorting and tile-based operations, we can provide a clean, high-level C++ structure to the compiler. Second, I will utilize Clad to automatically generate the backward pass. By relying on Clad's liveness analysis, the compiler will prove exclusive memory ownership and automatically eliminate the need for atomicAdd calls. To isolate the compiler complexity from the graphics complexity, the project will use a differentiable geometry path tracer as the foundational stepping stone. Beyond differentiable rendering, this work establishes a foundation for compiler-driven automatic differentiation of parallel C++ programs, enabling efficient gradient computation in a wide range of high-performance computing applications.

pythonc/c++machine learning+6
Student: Abdelrhman Elrawy
Code

Internationalization Support for Applications Built with MIT App Inventor

intermediate
MIT App Inventor•2026Varies175h (Medium)

This project aims to introduce a scalable and maintainable internationalization (i18n) system for applications built using MIT App Inventor. Currently, App Inventor does not provide a structured approach for handling multi-language support, making it difficult for developers to create globally accessible apps. The proposed solution introduces a key-based translation system that decouples user-visible text from UI components. The system integrates across multiple layers of App Inventor, including the Designer, Blockly, runtime, and build system, enabling automatic translation handling in generated applications. Key features include: - Automatic detection of user-visible text from component properties and Blockly blocks - A centralized translation editor for managing multi-language content - Context-based key generation to ensure stability and avoid ambiguity - Runtime translation using JSON for flexibility during development (Companion) - Build-time generation of native Android/iOS resources for efficient production builds The system is designed to be fully backward compatible and supports progressive adoption, allowing existing projects to continue working while enabling developers to gradually migrate to the new translation model. Deliverables include: - A working runtime translation system for App Inventor apps - Integration with Blockly for key-based text handling - Designer-level synchronization and key management - Build-time resource generation for native localization - End-to-end tested implementation with documentation

javagwtgoogle app engine+7
Student: Akash Gite
Code

Enhancing noaa_coops: Bringing Software Engineering Best Practices to Ocean Data Access

intermediate
IOOS•2026Varies175h (Medium)

The noaa_coops package provides oceanographic data access but has critical gaps: large date ranges fail without pagination, no retry logic for rate limiting, and NOAA's Derived Products are inaccessible. I will implement: (1) automated pagination respecting product-specific API limits, (2) throttling-aware retry logic with exponential backoff, (3) complete derived product support via a new method, (4) metadata retrieval fixes for historic current stations, and (5) numpy 2+ compatibility fix. Deliverables include a strengthened noaa_coops package with merged PRs addressing each issue, comprehensive pytest coverage (>90% for new code) and updated documentation with clear examples. This will transform noaa_coops into a production-ready package that oceanographers can rely on for large-scale research workflows.

pythonocean sciencejava+3
Student: Sreeya_C
Code

DeepForest: Recovering computer vision annotations from historical airborne imagery monitoring

advanced
NumFOCUS•2026$6k–$13.2k350h (Large)

After the 2010 Deepwater Horizon oil spill, airborne surveys produced 18,304 images with 2.6 million birds individually marked using a point-counting tool. The tool baked colored annotation dots directly into screenshot pixels no coordinates were ever saved. I built a six-stage recovery pipeline that extracts dot positions from corrupted screenshots, maps them to original high-resolution photographs via SIFT homography, and exports DeepForest-compatible training annotations. Tested on 34 images spanning 7 years and 10 annotators with zero failures: 70.8% detection accuracy, 98.3% position precision, 3,915 annotations recovered across 21 species. Training experiments confirmed that position accuracy of recovered coordinates not data volume drives downstream detector performance. GSoC deliverables: (1) Scale recovery to all 18,304 images with an optimized feature matching cascade targeting 80%+ geometric precision, (2) a quality-tiered dataset of 250,000–340,000 recovered annotations, (3) a fine-tuned airborne bird detector evaluated per-species on held-out colonies, (4) a tested DeepForest module with documentation, and (5) a blog post documenting the full recovery process including approaches that failed and why.

pythonjavascriptr+3
Student: vickysharma
Code

Guardrail Framework and Blue Track for OWASP FinBot CTF

intermediate
OWASP Foundation•2026Varies175h (Medium)

FinBot CTF has 16 Red track challenges where players attack a live AI agent. There is no defense side. Players can learn to exploit the agent but have no way to practice stopping the same attacks. This project builds three things. First, a pluggable guardrail framework inside BaseAgent that runs policy checks before and after every tool call. Second, five guardrail implementations covering goal hijacking, tool misuse, privilege abuse, memory poisoning, and inter-agent spoofing, mapped to ASI-01, ASI-02, ASI-03, ASI-06, and ASI-07 from the OWASP Top 10 for Agentic Applications. Third, a Blue track that converts existing Red challenges into paired Red/Blue challenges, where players score points by deploying guardrails that block specific attacks. Deliverables: bug fixes for three confirmed open issues, the finbot/guardrails/ module with full test coverage, five guardrail hooks wired into the existing CTF event bus, 4 to 5 paired Red/Blue challenge YAMLs, two new MCP attack scenarios, and contributor documentation.

pythonjavascriptjava+10
Student: stealthwhiz
Code
Showing 577 - 600 of 13453 Projects
2324252627
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal