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 Clear
3179 Projects Found
Sort by

Expose a Subset of ENA REST Services as MCP

beginner
Genome Assembly and Annotation•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 →
90h (Small)

The goal of this project is to provide a Model Context Protocol (MCP) server that is suitable for production and exposes expected REST endpoints from the European Nucleotide Archive (ENA) as organised, schema-driven tools for AI systems. Although ENA offers robust REST APIs for biological data access, direct integration with AI agents frequently results in inconsistent queries, low reproducibility, and lack of validation. In order to overcome this, the project implements an MCP-based interface layer that ensures predictable execution, provides a strict input/output schemas, and enables secure, secure communication with ENA services. A dynamic tool registry for flexibility, Pydantic for schema validation, httpx for asynchronous API communication, and a response normalisation layer for consistent outputs are all features of the FastMCP-built system. To ensure scalability and production readiness, it will also include a comprehensive error handling, testing, and containerised deployment using Docker and Kubernetes. A fully functional MCP server with several ENA capabilities (such as study, sample, and run queries), thorough test coverage, developer-friendly documentation, and a deployable system that is simple to interface with AI clients are some of the key deliverables. This project will enable more dependable AI-driven scientific workflows by improving the reproducibility, traceability, and accessibility of biological data.

pythonmysqljavascript+4
Student: Dineshkumar Anbalagan
Code
Proposal

Cognitive Ecosystem: Unified Agent Coordination, Observability, and Intelligence for MoFA

advanced
MoFA Org•2026Varies350h (Large)

MoFA agents currently operate as "black boxes" in isolation—they lack shared memory, structured handoff protocols, and cross-agent coordination. When a multi-agent swarm fails, there is no single distributed trace to follow and no system-wide intelligence to explain why. This proposal transforms MoFA from a collection of individual agents into a "Cognitive Ecosystem" by implementing a symbiotic coordination-and-observability layer. Building on the OTLP+Prometheus pipeline with a 336x performance gain and the core coordination traits I designed (PR #997), this project delivers: (1) An AgentHub Coordination layer featuring InMemoryVectorStore for semantic memory and ChannelHandoffProtocol for reliable task delegation; (2) A zero-copy EventRecord Bridge using tokio::broadcast to fan out state mutations; (3) An Observatory Intelligence Engine featuring a petgraph-powered Knowledge Graph for live topology mapping and a Z-Score Statistical Anomaly Detector for identifying rogue agent behavior (token burn, latency spikes). The result is a production-grade "Nervous System" for MoFA where every agent interaction is first-class, observable, and governed. Key metrics include: Zero-drop event propagation at 4000 EPS, <50ms graph query latency, 80%+ unit test coverage, and a full W3C TraceContext implementation for cross-agent waterfall visualization.

pythonrust
Student: Ashum9
Code
Proposal

Constellation Web Interface for Controlling and Monitoring Experimental Setups

intermediate
CERN-HSF•2026Varies175h (Medium)

During late-night beam tests, physicists must leave detector halls to find workstations with Qt installed just to check satellite status. This project creates a browser-based interface that lets researchers monitor and control Constellation experiments from any device on the lab network without installing software. The project delivers three components: (1) upstream contributions to Constellation's Python API adding callback mechanisms for satellite state changes and discovery events, plus porting C++ topic management classes to Python; (2) a WebSocket bridge wrapping ScriptableController and MonitoringListener via multiple inheritance to expose satellite control and monitoring to browsers; (3) a SvelteKit frontend implementing the full satellite state machine for real-time control and monitoring. I have verified the multiple inheritance approach through hands-on testing. Discovery, commands, heartbeat state tracking, and CMDP log callbacks all work through a single combined class. I also created a custom satellite and controlled it through the complete FSM cycle. Deliverables include merged upstream MRs for callback APIs and topic management, a working WebSocket bridge with callback-driven state updates, a browser dashboard with state visualization and command controls, a log viewer mirroring Observatory's subscription model, comprehensive documentation, and tests.

pythonc/c++machine learning+6
Student: VanitasCodes
Code

Develop Badgeyay into Complete Service

beginner
FOSSASIA•2018$1.5k–$3.3k90h (Small)

<p>The main goal of this year's GSoC was to develop <a href="https://github.com/fossasia/badgeyay" target="_blank"><strong>Badgeyay</strong></a> into a complete Service with services ranging from simple to complex functionalities which include :</p> <ul> <li>Modularizing the API and follow the best standards.</li> <li>Improving the Rest API and Resolving the known bugs.</li> <li>Improving current UI of Badgeyay and changing it along with GSoC Period by Using Ember JS and Semantic UI.</li> <li>Improving the Badge Layout and provide more features to the user. </li> <li>Implementing User Authentication and Integrating database management system into Badgeyay. </li> <li>Implementing a Badge Management System.</li> <li>Implementing Admin Panel.</li> </ul> <p>Tech Stack:</p> <p>The whole front end is shifted to Flask template to MVC frontend framework Ember JS. Everything in the frontend is divided into components and chaining of actions and models have been implemented. Semantic UI is used for styling purposes.</p> <p>The whole API is redesigned to follow JSON API specification using the marshmallow to make it compatible with data coming from Frontend. Firebase is also used to support admin and authentication functionalities from the backend flask server.</p>

pythonjavascriptandroid+7
Student: Parth Shandilya
Code
Proposal

Modernizing OpenELIS Frontend with TypeScript and Performance Optimization

advanced
OpenELIS Global•2026Varies350h (Large)

The current OpenELIS React frontend is primarily written in JavaScript and faces challenges in maintainability, scalability, and performance as data complexity increases. This results in inconsistent type usage, increased bugs, and inefficient rendering in data-heavy workflows such as patient management, sample tracking, and result entry. This project aims to modernize the frontend by incrementally migrating the codebase to TypeScript and applying proven React performance optimization techniques. The migration will introduce a centralized type system for API models, forms, and reusable components, ensuring consistency and reducing duplication across the codebase. The project will follow a phased approach: first establishing a strong TypeScript foundation with shared type definitions, then incrementally migrating utilities, components, and high-impact screens. In parallel, performance optimizations will be implemented using profiling-driven techniques such as memoization, virtualization for large datasets, improved server-state handling, and code splitting. Deliverables include: - Incremental migration of frontend codebase to TypeScript - Centralized and reusable type definition system - Performance improvements in key workflows - Reduced bundle size and improved rendering efficiency - Documentation and migration guide for future contributors This project will significantly improve the maintainability, developer experience, and performance of the OpenELIS frontend, making it more scalable for future growth.

postgresqljavascriptjava+2
Student: Manroop Singh
Code

Implementation of Newsfeed (a social feature) in Rocket.Chat Server

advanced
rocket.chat•2019Varies350h (Large)

<h3>Implementation of Newsfeed (a social feature) in Rocket.Chat Server</h3> <p>This project adds a newsfeed for every user. In it, the users can follow other users. Whenever a user posts something in a public channel or does any public activity, it would appear in the newsfeed of all his followers with a link to the original post in the original channel. This would greatly help in discovering new conversations, increasing accountability of people in the organisation &amp; increasing many folds the time a user spends on RC</p> <p><strong>The most challenging part of creating the newsfeed is to make it scalable to support a large number of concurrent users (by using an adaptive follower/following relation model) and to benchmark the server performance in relaying the correct messages with filters. This is being done by using proper schema and proper database queries. Messages in newsfeed are fetched in real-time from messages stored for other channels.</strong></p> <p><em>Key Features:</em></p> <ul> <li>Support for Rich Message blocks</li> <li>Auto-summarization of messages to prevent spam in newsfeed</li> <li>Expandable embedded conversations</li> <li>Upvoting System &amp; Trending messages</li> <li>Group messages by origin user, date, channel etc.</li> <li>Integration with other projects</li> </ul>

javascriptwebrtcmeteor.js+18
Student: Amish Mittal
Code

Fixes and performance improvements

Intermediate
•Varies175h (Medium)

The eXpress Data Path (XDP) feature in the kernel enabled high performance programmable packet processing using BPF. This is achieved by way of the XDP hook for attaching BPF programs to a very early stage of packet processing in the network drivers. This allows very high packet processing performance, and XDP programs have access to the full packet data and can filter or steer packets using kernel helpers and different return codes. The XDP_REDIRECT return code is the most flexible of the return codes and is used to direct packets to other places in the system, including other network interfaces, other CPUs, or straight to userspace. While the redirect feature is conceptually simple from the BPF user's point of view, the implementation of it in the kernel uses various tricks to improve performance as packets traverse the different parts of the kernel. This project aims to improve various outstanding issues of the XDP redirect facility. The exact tasks taken on will be up to the mentee's particular interests and skill set, and can include implementing missing pieces of functionality, performance analysis and improvements as well as adding kernel selftests. We have a list of issues to tackle which includes things like: - Implementing missing redirect features for Generic XDP - Improving performance through bulking of operations on redirect - Adding selftests for redirect map types - Improving the usability of BPF samples using redirect

TBA
Proposal

Extending the capabilities of OpenTRIM

intermediate
Open Technologies Alliance - GFOSS•2025Varies175h (Medium)

OpenTRIM is a C++ Monte Carlo simulation framework that models the interaction of ions with matter, tracking energy deposition and defect creation. Currently, it includes a fixed tallying system for recording standard outputs, such as energy lost to ionization or defects. This project aims to extend OpenTRIM's capabilities by implementing a flexible, user-customizable tally system. The new tally system will allow users to define, via JSON configuration, what simulation events to track (e.g., ion stopping, vacancy creation), how to bin data (e.g., in cylindrical or Cartesian coordinates), and what physical quantities to record (e.g., ion depth, deposited energy). It will be implemented as a new class hierarchy in C++, inheriting from the existing tally class, and will make use of the ArrayND data structure for multidimensional data storage. Deliverables include: a) A customizable tally class with support for user-defined event handling b)JSON-configurable tally setup (geometry, energy bins, spatial bins, etc.) c) Sample tally implementations (e.g., ion range profiling) d) Unit tests, documentation, and tutorials for extending the system This work will empower researchers and developers to tailor OpenTRIM output to their specific simulation needs, improving its usability and scientific value.

pythonmysqljava+7
Student: Iridanos
Code
Proposal

Ecosystem integrations & tutorials for AI Gateway (2026 Term 1)

Intermediate
•Varies175h (Medium)

This project focuses on creating clear, approachable, and practical documentation that shows how to integrate kgateway’s AI Gateway (agentgateway) with popular AI tools, developer UIs, and other CNCF ecosystem projects. Its aim is to make kgateway’s documentation more practical, discoverable, and reflective of real ecosystem usage, so users can better understand what’s possible and how kgateway fits into the broader AI and cloud-native landscape. Examples of integrations and tutorials include: 1. Open WebUI / OpenAI Codex / Claude Code: Step-by-step guides showing how to connect agentgateway to interactive UIs for testing, demos, and common integration patterns 2. Demonstrate how agentgateway fits into the CNCF ecosystem by integrating with tools such as: a. Argo Rollouts: Update the Argo Rollout Gateway API guides with the latest agentgateway example config. Create docs using Argo Rollouts with AgentgatewayBackends for LLM providers and MCP servers. b. KServe: Using agentgateway as an ingress for model serving, enabling rate limiting, authentication, and observability c. Knative: Add a guide for setting up kgateway with agentgateway as a custom ingress gateway Expected Outcome: 1. A series of integration guides and tutorials demonstrating how to use kgateway with AI developer tools and CNCF ecosystem projects 2. New examples, improvements, and documentation pages....

TBA
Proposal

MLIR Convolution Vectorization

Intermediate
•Varies175h (Medium)

The RISC-V Mentorship Program enables one or more 12-week internship-style projects per session, funded by RISC-V, to match mentors/project leaders together with mentees/interns . Mentees are guided through a series of milestones by one or more project mentors, with whom the mentees meet on a weekly basis. Convolution is the core operation of deep learning models and computer vision applications. MLIR supports various convolution operations. Our project is to vectorize them for the RISC-V backend. There are several methods to implement convolution vectorization, such as optimizing nested loops, implementing vectorization algorithm, converting to GEMM, etc. This project needs to choose a vectorization method and implement a conversion pass for the convolution operations. As for the vector semantic support, MLIR has the “Vector” dialect for the general vector abstraction, and it also allows the backend-specific vector dialect, such as the “x86vector” dialect, “arm_neon” dialect, and “arm_neon” dialect. Like these dialects, the project also needs to propose an “RVV” dialect and work with existing dialects and tools. Deliverables: - An MLIR “RVV” Dialect. (Operations in the dialect can support the convolution vectorization) - A conversion pass to vectorize convolution operations in “Linalg” dialect with “RVV” dialect enabled. - A conversion pass to lower the operations in “RVV” dialect to “LLVM IR” dialect. - Unit tests for “RVV” dialect and conversion passes.

TBA
Proposal

Agentic AI for Kubernetes Operations on NRP

advanced
UC OSPO•2025Varies350h (Large)

The original proposal for this project focused on building a machine learning service to improve monitoring within the Seam and National Research Platform (NRP) environments. The goal was to analyze Prometheus metrics, detect anomalies proactively, and use NRP’s GPU and managed LLM resources to provide human-readable explanations and root cause analysis through Seam’s portal. This approach aimed to give the Seam/NRP community an intelligent tool for faster troubleshooting and more resilient operations. As the work progressed, and with the rapid growth of agentic AI approaches, the project shifted toward building an Intelligent Kubernetes Management and Observability System, inspired by the INFOGENT design. Rather than focusing solely on anomaly detection, the system was developed as a modular Python framework that integrates Kubernetes operations with large language model–driven explanations. It classifies user input as either an operational command or a documentation query, executes the corresponding action, and returns either the system output or a clear explanation drawn from NRP knowledge. The outcome is a practical, open-source framework that provides both command execution and AI-assisted guidance. It lowers the barrier for researchers working with Kubernetes, helps them understand and troubleshoot workloads more easily, and extends the Seam initiative by showing how agentic AI systems can enhance usability in high-performance computing environments.

pythonc/c++visualization+5
Student: Manish Kamalakar Reddy
Code
Proposal

Open Event Organizer Android Application

intermediate
FOSSASIA•2017Varies175h (Medium)

<p>Open Event Organizer is an Android Application for Event Organizers and Entry Managers. It is a client side application for another project under FOSSASIA named Open Event Organizer Server.</p> <p>The core features implemented in the app are:</p> <ul> <li>Scan a QR code to validate an attendee's check-in</li> <li>Overview of Sales</li> <li>Ticket Management</li> <li>Edit Basic Event Details</li> <li>Offline Support to the above-mentioned features</li> </ul> <p>The app is designed on the Model View Presenter Architecture which enables robust unit testing. Each feature implemented in the app has a complete coverage of unit tests. The app uses most of the modern open source technologies like ReactiveX API for multithreading, Dagger for dependency injection, OkHttp+Retrofit for handling network requests, Evernote's android-job for handling jobs in the background, JSON API-converter to handle JSON API schema responses, Google Vision API for scanning QR code, Glide for image loading/caching, Jackson to parse JSON data, Leakcanary to detect memory leaks, Lombok for logs, Mockito Framework for unit tests, DbFlow ORM database library, Data Binding etc. Material Design Guideline is followed for the UI in the app.</p>

pythonjavascriptandroid+7
Student: mejariamol
Code
Proposal

Create an MCP-based AI agent to help LF certificate prep (2025 Term 2)

Intermediate
•Varies175h (Medium)

You will create an AI agent based on open-source Large Language Models (LLMs) running on the CNCF WasmEdge runtime and an MCP server. The application will tie together key components in a modern AI agent stack to create a useful application. The AI agent will ask, answer, and explain practice questions for a specific tech certification program. It enables students to study for the certificate tests more effectively. Expected Outcome: 1. Deliverable 1: create a MCP server with 2 functions a. get_random_question(): The function selects a random question from a list. It returns both the question and the answer. This function is called by the LLM when it detects that the user asked for a new practice question. b. get_question_and_answer(): The function searches an input text from the database for an corresponding question and answer. 2. Deliverable 2: create a practice question / answer database on a subject that you are most familiar with. The MCP functions will 3. Deliverable 3: Create an agent app based on the LlamaEdge framework with a 4. Workflow 1 a. The user asks a question. The LLM calls MCP function get_question_and_answer() b. The agent adds the answer to the context c. The LLM converse with the user with knowledge about the question and its answer 5. Workflow 2 The user asks for a practice question. The LLM calls MCP function get_random_question() to get the question and answer.

TBA
Proposal

Extract important information from scientific papers

intermediate
Genome Assembly and Annotation•2022$3k–$6.6k175h (Medium)

During GSoC 2021, BioBERT and RegEx/string matching technique based “Named Entity Recognition” (NER) system was developed to recognize and extract data classes of Mutation, Gene, and Gene-Var combo, Strains, Variants, Variation type, and Functional effect. But it has limitations that it can still not recognize many entities of predefined classes due to being trained on a dataset having less training data in natural language form and less generalized RegEx/string matching rules. Also, due to the poor entity normalization approach, many extracted entities are being ignored in the final output stage of the pipeline. This project proposal aims to increase the entity detection capabilities of this “Named Entity Recognition” (NER) system by firstly integrating additional RegEx/string matching rules in the current pipeline. Secondly, by combining other training datasets with the existing IDP4 dataset and then extending this combined training dataset using active learning to capture more data classes in natural language form. Lastly, re-training the current BioBERT model using a modified approach and making the entity standardization approach more general and scalable. Along with improving entity recognition of existing data classes, this proposal also aims to extend the current “Named Entity Recognition” (NER) system to extract data classes related to the CRISPR-cas9 experiment.

pythonmysqljavascript+4
Student: Malay Joshi
Code

Agentic Cognitive Firewall SDK

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

LLM agents built with LangGraph and LangChain retrieve documents, call tools, and write to memory - but nothing validates what enters the model's context. A poisoned RAG document can hijack an agent's behaviour. A malicious tool parameter can exfiltrate data. A single memory write can silently alter every future response. There's no standard security layer for any of this. ACF-SDK is a Zero Trust firewall that sits between the agent and the LLM - intercepting every input across four hooks (prompt, context, tool call, memory) and enforcing policy-as-code decisions through an isolated Go sidecar. I want to take this pipeline from hardcoded ALLOW to real enforcement: upgrade the semantic scanner to catch paraphrased attacks, wire scanner signals into the real sidecar, build memory write protection with HMAC and provenance tracking, ship a Docker demo anyone can clone and run in 5 minutes, and stress-test the whole system against adversarial evasion techniques with a technical evaluation report. The foundation is already built. I've shipped 6 PRs - semantic scanner, benchmark harness, LangGraph adapter, Rego policy templates for all four hooks, audit logger, and a Go scan stage implementation. 155 tests passing. GSoC wires these components into a running system and proves they hold up under real attacks.

pythonjavago+2
Student: Pranjal Udhwani
Code
Proposal

ImageLab Interactive Learning

intermediate
C2SI•2026Varies175h (Medium)

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.

pythonjavago+2
Student: Chetan Barakki Satish Kumar
Code
Proposal

Extensions to the Scenic Driving Domain

intermediate
UC OSPO•2026Varies175h (Medium)

Scenic is a probabilistic programming language for generating and verifying environments of autonomous cyber-physical systems. Its driving domain- the primary interface for autonomous vehicle (AV) testing- is a Python library that parses OpenDRIVE road-network files and exposes lanes, roads, intersections, traffic signals, and agents as first-class Scenic objects. While the driving domain is powerful, it has several concrete limitations that hinder real-world usage: assertion failures and geometry artifacts on certain OpenDRIVE maps; a coarse-grained centerline-following model that accumulates error on curved roads; incomplete extraction of semantic road metadata; and absent lane-signal linkage that makes it impossible to write autopilot behaviors that respect traffic laws. This proposal addresses all of these gaps across two major tracks and five subtasks, matching the project outline provided by the mentors: - Track 1 (~4 weeks): Robustness - fix known bugs, expand the test suite. - Track 2 (~5 weeks): Features - Frenet-frame geometry, lane-following distance, semantic tags, signal-lane linkage, and modular scenario components. Each subtask explained in the proposal will produce independently reviewable pull requests, letting mentors integrate work incrementally. The result is a driving domain that is meaningfully more robust, more expressive, and better validated than today.

pythonc/c++visualization+5
Student: Ashwin Prabou
Code
Proposal

Bilingual dictionary enrichment via graph completion

advanced
Apertium•2018Varies350h (Large)

<p>Graph representation is very promising because it represents a philosophical model of a metalanguage knowledge. Knowing several languages, I know that it could be hard to recall some rare word and it is easier to translate from French to English and only then to Russian - because I forgot the word-pair between Russian and French. This graph representation works just like my memory: we cannot recall what is this word from L1 in L2. Hmm, we know L1-L3 and L3-L2. Oh, that's the link we need. Now we know L1-L3 word-pair. So, as we work on <strong><em> natural</em></strong> language processing, let's use <strong><em>natural</em></strong> instruments and systems as well.</p> <p>The main benefit of this project is reducing human labor and automatization of part of the dictionary development.</p> <ol> <li>Finding lacunae in created dictionary</li> <li>Dictionary enrichment based on algorithm that offer variants and evaluation of these variants.</li> <li>A potential base for creating new pairs.</li> </ol> <p>List of main ideas:</p> <ol> <li>Classes to create the most appropriate type of information</li> <li>Work with subraphs (connectivity components) to reduce the complexity of calculations</li> <li>Filtration algorithms</li> <li>Vectorization to increase efficiency</li> <li>Develope different metrics to reach quality of translation</li> </ol>

pythonc++xml+4
Student: Evgenii Glazunov
Code
Proposal

Implementing Service Worker Infrastructure in Servo Browser Engine

intermediate
Mozilla•2016Varies175h (Medium)

<p>Servo has support for Web Workers, and the new Fetch Api whose development is in progress is another new standard, that aims to replace XMLHttpRequest (XHR), and provides a cleaner api for anything involving requests and responses.The Fetch api spec also has a subsection which details on handling fetch calls within a service worker context. <a href="https://slightlyoff.github.io/ServiceWorker/spec/service_worker/" target="_blank">Spec</a> Service Workers are the new standard, for modern web apps, which aims to bring native app like experience to browser based apps, by providing a programmable api, for caching certain paths of pages, ,manipulating routing within an application,intercepting network requests according to user logic.</p> <p>Servo has a partial implementation of Fetch api, but the Service Worker api’s are currently missing and if implemented, Servo will be able to intercept network calls made from within the Service Worker’s context, the “handle_fetch” subsection of the Fetch Spec, is to be implemented. <a href="https://fetch.spec.whatwg.org/" target="_blank">Spec</a></p> <p>My project is to have a partial implementation of the new Service Worker Api and its helper interfaces, in Servo. The project is focused on working on parts of the Service Worker Specification which revolves around intercepting network requests.</p>

pythonjavascriptc+++8
Student: creativcoder
Code
Proposal

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

Physics-based sonar simulation and new examples with commonly used hardware for underwater robotics

advanced
Open Robotics•2025Varies350h (Large)

The multibeam sonar is a ray-based plugin designed to simulate the physics of acoustic signal propagation, including phase and reverberation effects. Originally developed for ROS 1 Noetic and Gazebo Harmonic as part of the DAVE project, it is currently being migrated to Gazebo Harmonic and ROS 2 Jazzy. This project aims to complete the migration and enhancement of the multibeam sonar plugin, with three main deliverables. The first is an enhanced plugin with improved performance through the introduction of half-precision calculations in CUDA. It is expected that this modification will greatly improve frame refresh rates. Numerical accuracy must be carefully taken into account when implementing it, however, and this should involve thorough testing and evaluation using quantitative metrics in comparison to the performance of the single-precision code. The second deliverable is the extension of simulation capabilities to support additional sonar types. Building on the existing multibeam sonar, it should be feasible to implement a side-scan sonar with for seafloor imaging, taking into account shadow analysis and directivity patterns like side lobes, for example. Finally, benchmark integration is essential to make the simulation more practical and accessible. This involves incorporating hardware that is often used in maritime robotics, like the BlueROV, and not only efficiently modeling the vehicle and its sensors, but also offering examples that are effortless to use. These benchmarks will enable the simulation to be validated and more available and beneficial for the general community, researchers, and developers.

pythonc/c++ros+5
Student: Helena Moyen
Code

StablePay: Enabling a Multi-Stablecoin Payment Experience

intermediate
AOSSIE•2026Varies175h (Medium)

Currently, the StablePay ecosystem only processes payments for Djed Osiris. As the Djed protocol expands to include new variants like Djed Shu, Tefnut (ETH-backed), and Isis (ERC-20-backed), the payment infrastructure must evolve. The goal of this project is to refactor the StablePay widget, merchant dashboard, and demo sites to seamlessly support any Djed variant without hardcoded assumptions. Additionally, this project will introduce support for the Gluon protocol, which entails deriving the essential mathematical formulas required for pre-calculating neutrons and protons. To achieve this, I will develop protocol adapters that interact with abstracted Djed interfaces, allowing different stablecoins to be plugged in via configuration. I will upgrade the merchant dashboard to enable multi-stablecoin management, allowing merchants to set preferred price feeds and monitor per-stablecoin revenue. Additionally, I will build deployment tooling to auto-generate config bundles from on-chain metadata and improve the end-user UX to handle coin selection, oracle status, and fallback logic gracefully. Ultimately, this project will transform StablePay into a highly scalable, agnostic payment gateway. Deliverables will be secured with comprehensive integration testing (using Foundry/Hardhat) and frontend end-to-end testing, alongside detailed documentation for merchants to easily onboard new networks and protocol versions.

pythonjavascriptswift+8
Student: Amrit Kumar Yadav
Code
Proposal

Add anova Classdef Object to the GNU Octave Statistics Package

advanced
GNU Octave•2026Varies350h (Large)

This project implements an anova classdef for the GNU Octave statistics package, providing a unified object-oriented interface for one-way, two-way, and N-way analysis of variance. The anova class delegates core computation to the existing anova1, anova2, and anovan functions, preserving their tested logic while exposing a clean, MATLAB-compatible OOP API with properties (Coefficients, anova table, fitted values, residuals, diagnostics) and methods (summary, multcompare, plotDiagnostics, predict, getEffectSizes). The class stores model state, enabling interactive post-hoc workflows without refitting. Beyond the classdef, the project delivers targeted performance improvements to the underlying functions: vectorizing loop-heavy group statistics in anova1 with accumarray, vectorizing anova2 SSE computation, reducing memory in anovan interaction column construction, and adding NaN handling to anova2. Deliverables: (1) anova classdef with constructor, properties, and core methods, (2) summary and display methods with formatted ANOVA table output, (3) multcompare method for post-hoc pairwise comparisons, (4) plotDiagnostics method for residual and leverage plots, (5) performance optimizations to anova1, anova2, anovan internals, (6) NaN handling for anova2, (7) comprehensive BISTs and Texinfo documentation, (8) benchmark suite. All computation reuses existing functions with no architectural rewrites.

c++hg
Student: beingamanforever
Code
Proposal

Improving SegAnnDB genomic segmentation app

intermediate
Canadian Centre for Computational Genomics (C3G) - Montreal node•2016Varies175h (Medium)

<p>SegAnnDb (Segmentation Annotation Database) is a web app, which helps researchers analyze a chromosome profile for copy number alterations in genes. Many studies have found that copy number variations are linked to diseases like - cancer, tumors, Alzheimers etc. Study and analysis of CNVs is an active area of research in bioinformatics.</p> <p>SegAnnDB allows users to upload a profile and then annotate it on basis of <code>loss</code>, <code>gain</code>, <code>deletion</code>, and <code>amplification</code> Various profiles are stored in the webapp and researchers can work with them. SegAnnDB provides most accurate results when compared to other applications. It uses concepts of machine learning and data analysis to arrive at most accurate models.</p> <p>The aim of this project is to add various significant features into SegAnnDB , some of these will be -</p> <ul> <li>Test Suite</li> <li>Permissions System on profiles</li> <li>Replace large PNGs by sub regions of chromosome</li> <li>Faster Deletion of profiles</li> <li>Sharing of annotations </li> <li>Safe cleaning of generate log files</li> <li>Packaging it as docker container</li> </ul> <p>This project will greatly improve collaboration on SegAnnDB, it will also make its development easier and more people will start using it in their research and analysis.</p>

pythonjavascriptsql+2
Student: abstatic
Code
Showing 3073 - 3096 of 3179 Projects
127128129130131
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal