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

Porting Chebfun to GNU Octave

intermediate
GNU Octave•2025$3k–$6.6k

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)

I propose to work on the following project: porting the Chebfun package to GNU Octave. Chebfun is a numerical computation package for MATLAB that provides a framework for representing functions in a symbolic manner using ”Chebyshev technology”, a term coined by the package authors to describe the use of Chebyshev polynomials to represent functions up to machine precision. GNU Octave is supposed to be mostly compatible with MATLAB, so Chebfun should ideally work without change on the former, but there are some slight differences and unimplemented features in Octave that make this difficult. Primarily, the main issue is that Octave’s support for object-oriented programming (classdef) is not as feature complete and as stable as MATLAB’s, which is a major problem since Chebfun is written in classdef. The goal of this project is to port Chebfun to GNU Octave, and to make it work as a dropin replacement for the MATLAB version. Since fixing classdef is not a feasible/recommended goal for a GSoC project, I will instead focus primarily on making the necessary changes to the Chebfun codebase to make it work in Octave. Along the way, I will compile new information about the status of classdef in Octave, and I will share my findings with the Octave developers, and perhaps aid in some changes to the Octave codebase itself.

c++hg
Student: Thomas Kolman
Code
Proposal

Partial rendering of front-end, ReactJS based applications on JVM by using Nashorn engine

advanced
Health Information Systems Programme•2016Varies350h (Large)

<p>Web Sites have evolved a lot from static mundane texts to interactive ajax based web sites and today’s Single Page Applications which provides user with a very intuitive experience. React has been one of the front-runner frameworks spearheading this more robust front ends rendering SPA frontend dramatically fast. This has been at the cost of getting down a barrage of javascript in the beginning and rendering it on the fly using the browser’s Javascript and rendering engines. This is counter intuitive to the User Experience goals of a single page application paradigm.</p> <p>A trivial solution that comes into mind is to push this workload to the server to process this Logic in the back end and send it to the server. This raises the concerns of the requirement of an Isomorphic JS backend such as NodeJS. However, with a back end that utilize Java 8 which comes packing with a much more advanced Javascript Engine - Nashorn, possibilities crop up.</p> <p>The main idea of this project wraps around finding an efficient paradigm to develop SPA’s by pre-rendering partially or whole HTML DOMs in the back end and delegating the basic DOM rendering of the static or partially static contents to the browser.</p>

javascriptandroidjava+2
Student: Dehan de Croos
Code

Integration of CircuitVerse with LMS Platforms

intermediate
CircuitVerse.org•2021$3k–$6.6k175h (Medium)

<p>CircuitVerse is an online circuit simulator that can be used as an online classroom companion for circuit simulation related needs of teachers and students.</p> <p>The aim of the project is to integrate CircuitVerse with as many Learning Management Systems such that teachers and students of different educational institutions can use CircuitVerse without leaving their favourite Learning Management Systems (Like Moodle, Canvas, Sakai etc.)</p> <p>A novel method has been developed to integrate <a href="https://www.imsglobal.org/activity/learning-tools-interoperability" target="_blank">Learning tools Interoperability</a> specifications with the existing Ruby on Rails codebase of CircuitVerse such that the platform can be used seamlessly with LTI supported Learning Management Systems (Like Moodle, Canvas, Sakai etc.)</p> <h4>Read More</h4> <p><a href="https://github.com/CircuitVerse/CircuitVerse/pull/2382" target="_blank">Final Pull Request</a> | <a href="https://blog.circuitverse.org/posts/ayan_phase_1_report/" target="_blank">First phase report</a> | <a href="https://www.ayanbiswas.in/tag/gsoc21/" target="_blank">See all blogs</a></p>

postgresqljavascriptbootstrap+8
Student: AYAN BISWAS
Code

Enhancing Zulip API Documentation Framework

intermediate
Zulip•2021Varies175h (Medium)

<p>The primary aim of this project is to make enhancements to Zulip’s REST API Documentation framework, which allows writing API Documentation based on the OpenAPI standard with built-in automated tests.<br> Major tasks include modifying the framework and testing to allow generating API pages directly from OpenAPI data and removing the redundant templates, and adding support for auto-generated API bindings by integrating different tools into the framework.<br> The docs will also be visually enhanced by improving the organisation and UI of /register and /events endpoints, and /api pages in general. This would include major design changes to the documentation pages to improve the overall user experience. Further, the OpenAPI data for currently undocumented /api endpoints will be added to improve the endpoint coverage by the docs.<br> This project would also involve fixing the currently open issues related to API Docs area, majority of which improve the testing of OpenAPI data, as well as making various API migrations with appropriate updates in OpenAPI data. Also, improvements would be made to the organisation of OpenAPI data and its testing/error messages to make it easier to maintain and work with.</p>

pythonjavascriptdjango+5
Student: Suyash Vardhan Mathur
Code
Proposal

Efficient syscall tracing for strace

intermediate
strace•2019Varies175h (Medium)

<p>strace currently adds significant overhead to any application it traces. Even when users are interested in a handful of syscalls, strace will intercept all syscall made by the observed processes, involving several context switches per syscall.</p> <p>Since Linux 3.5, userspace applications can rely on seccomp-bpf to filter the syscalls they want to trace. In that case, the set of monitored syscalls is filtered in the kernel, using cBPF, before any context switch to userspace. strace could leverage seccomp-bpf to avoid tracing syscalls users don't want. The tracing landscape of Linux also drastically evolved in recent years. In particular, user applications can rely on eBPF programs to filter and aggregate data of interest in the kernel, with low overhead.</p> <p>During this Google Summer of Code, I will finish and merge the works started to 1) rely on seccomp-bpf to filter syscalls in kernel space and 2) allow strace to use alternative backends. That second work will come with a tracepoint/BPF proof of concept to ensure strace supports diverse backends, beyond the usual ptrace model.</p>

clinuxshell script+6
Student: Paul Chaignon
Code
Proposal

Webservices in Joomla

intermediate
Joomla!•2019Varies175h (Medium)

<p>1) Web services in Joomla. Joomla is popular CMS, which is actively developing and it is very important to implement web services for further development. Web services will implemented for next components:</p> <p>com_content</p> <p>com_contact</p> <p>com_newsfeeds</p> <p>com_weblinks</p> <p>com_media (custom)</p> <p>com_menus</p> <p>com_categories</p> <p>com_contenthistory</p> <p>com_finder/com_search (read only as search and not CRUD)</p> <p>com_languages (both languages and content languages)</p> <p>com_messages</p> <p>com_modules/com_templates</p> <p>com_tags</p> <p>com_redirect</p> <p>com_plugins (edit settings only)</p> <p>com_config (edit settings only)</p> <p>2) Integrate entities layer (<a href="https://github.com/joomla-framework/entities" target="_blank">https://github.com/joomla-framework/entities</a>) in Joomla. The entity layer is a very important implementation for developers. Working with entity is more convenient than working with database directly. Since Joomla is an open source project, this implementation will help many developers.</p>

javascripthtmlphp+7
Student: Oleksandr Samoilov
Code
Proposal

Simulated memory controller

advanced
lowRISC•2020Varies350h (Large)

<h3>Project goal</h3> <p>The goal of this project is to devise and implement a simulation-ready memory controller dedicated to benchmarking processor cores implemented on field programmable logic, that will produce delays much closer to a system where the memory interface is running at a much slower clock speed. This can take two forms.</p> <ul> <li>A simulation model for a memory controller that is tunable.</li> <li>A synthesizable module to be placed between the soft core implementation and an existing non-tunable DRAM controller.</li> </ul> <h3>Novelty and benefits to the community</h3> <p>So far, papers have been reluctant to provide accurate processor core performance figures extrapolated from FPGA implementation because DRAM controllers have an unrealistically high clock speed clock speed relatively to a soft core, compared to an ASIC core implementation. Providing the community with open source tunable memory controller models dedicated to the benchmarking of soft cores will greatly help producing more accurate and interpretable core and accelerator performance figures without requiring an ASIC tape-out in the first place, which is often not even an option.</p>

linuxverilogfpga+5
Student: Flavien Solt
Code
Proposal

Apache Fory C++ & Rust gRPC Integration

advanced
Apache Software Foundation•2026Varies350h (Large)

Apache Fory provides high-performance serialization & deserialization and code generation from IDL, but it currently lacks end-to-end gRPC service integration for C++ and Rust. As a result, developers may still need to rely on external toolchains (e.g. protoc/prost) to generate service bindings, which prevents Apache Fory from being used as a complete gRPC solution. This proposal aims to enable Apache Fory to generate gRPC-compatible client and server code for both C++ and Rust, while reusing the existing gRPC runtimes (gRPC C++ and tonic). The core idea is to extend the Apache Fory compiler to generate service stubs and integrate Fory's serialization & deserialization into the gRPC pipeline by replacing the default codec (protoc and prost). The design decouples API definitions from transport- layer bindings and introduces reusable codec implementations. The project will also include comprehensive testing (unit, differential, and cross-language), CI integration, and documentation. This work will make Apache Fory a practical alternative to existing protobuf-based toolchains in gRPC frameworks and provide a reference architecture for adding gRPC support to other languages in the future.

pythonjavascriptjava+7
Student: Peiyang He
Code
Proposal

Developing a FHIR Resource Tabular Viewer for Efficient Data Exploration.

beginner
Data for the Common Good•2025Varies90h (Small)

Healthcare data is critical for decision-making, but the FHIR (Fast Healthcare Interoperability Resources) format, while powerful, can be challenging to navigate for many users. Our project addresses this accessibility gap by creating an intuitive tabular viewer that transforms complex nested FHIR resources into easy-to-understand tables. We're developing a Python-based solution that will automatically extract and organize FHIR data into user-friendly tables, making it immediately more accessible to researchers, clinicians, and community organizations. By simplifying how people interact with health data, we remove technical barriers that often prevent valuable insights from reaching those who need them most. Our deliverables include: A Python library that converts FHIR resources to tabular format An interactive web interface for exploring and filtering the data Documentation and examples to support adoption by various user groups Integration with existing FHIR servers for seamless data access This tool will democratize access to health information by making complex data structures approachable for everyone from data scientists to community health workers. When healthcare data becomes truly accessible, it empowers better decisions and ultimately improves health outcomes in our communities.

pythonjavascriptkubernetes+2
Student: Manjula
Code

coala: coala-html and coala website

intermediate
Python Software Foundation•2016Varies175h (Medium)

<h5>coala website and coala-html</h5> <p><em>coala-html</em> is a console application used to display results from coala-json as an interactive web page. Prototype is available at <a href="https://github.com/coala-analyzer/coala-html/tree/tushar-rishav" target="_blank">Github</a>.</p> <p><em>coala website</em> a main website for coala with coala demo integrated. It’d be written from scratch with improved UI and features.</p> <p>Proposed features are:</p> <ul> <li>coala-html<ul> <li>Improve UI for Logs and Results by implementing Material Design.</li> <li>Implement better search feature. Create a Fuzzy Search module.</li> <li>Add UnitTest</li> </ul> </li> <li>coala-website<ul> <li>Implement a demo of coala within coala website allowing users to run coala on their code snippet from within their web browser.</li> <li>Available at <a href="https://gitlab.com/coala/website" target="_blank">Gitlab</a></li> </ul> </li> </ul>

pythonmercurialjavascript+3
Student: tushar-rishav
Code
Proposal

Multimodal Large Model Joint Learning via KubeEdge-Ianvs Reproduction (2024 Term 3)

Intermediate
•Varies175h (Medium)

KubeEdge-Ianvs currently focuses on edge-cloud collaborative learning (training and inference) for a single modality of data. However, edge devices, such as those in autonomous vehicles, often capture multimodal data, including GPS, LIDAR, and Camera data. Single-modal learning can no longer meet the precise inference requirements of edge devices. Therefore, this project aims to integrate mainstream multimodal large model joint learning algorithms into KubeEdge-Ianvs edge-cloud collaborative learning, providing multimodal learning capabilities. Expected Outcome: A benchmark suite for multimodal large language models deployed at the edge using KubeEdge-Ianvs - Modify and adapt the existing edge-cloud data collection interface to meet the requirements of multimodal data collection - Implement a Multimodal Large Language Model (MLLM) benchmark suite based on Ianvs - Reproduce mainstream multimodal joint learning (training and inference) algorithms and integrate them into Ianvs single-task learning - (Advanced) Test the effectiveness of multimodal joint learning in at least one of Ianvs' advanced paradigms (lifelong learning, incremental learning, federated learning, etc.).

TBA
Proposal

Browser-Based Graphical Interface for JuliaBUGS

advanced
The Julia Language•2025$6k–$13.2k350h (Large)

JuliaBUGS is a modern Julia implementation of the classic Bayesian Inference using Gibbs Sampling — BUGS language for Bayesian modeling, combining BUGS’s intuitive model specification with Julia’s high-performance sampling methods like Hamiltonian Monte Carlo. This project proposes a browser-based graphical model editor for JuliaBUGS, enabling users to visually construct probabilistic graphical models by adding nodes and drawing arrows, instead of writing code. Built using React with TypeScript and React Flow, the web interface will support adding, connecting, grouping, and editing random variables and deterministic nodes via an interactive canvas. Users can specify probability distributions and hyperparameters through intuitive forms. The editor will export model structures to JSON and generate valid JuliaBUGS (or BUGS) code. The GSoC project will focus entirely on delivering a polished, user-friendly frontend with clear usage examples and tutorials. Inspired by tools like DoodleBUGS (for WinBUGS or MultiBUGS), shinystan, and the R Package causact, this editor aims to make model specification more accessible and streamline the Bayesian modeling workflow.

cjavascriptc+++12
Student: Shravanpuri Goswami
Code
Proposal

Hyperledger - Learning Tokens @ Hyperledger Besu Mentorship Project

Intermediate
•Varies175h (Medium)

Learning Tokens register the process of transfer and acquisition of knowledge. They track what we know and how we learned it in individual profiles that help personalize education. They measure engagement in the transfer of knowledge, support educational management, and foster Anatole France's words, nine-tenths of education is encouragement. Learning Tokens recognize, register, and reward community engagement in collective learning while certifying skills acquisition and individual competencies. In 2021, we did a global directory of DLT/Blockchain learning places. Last year, we defined artifacts for learning tokens, and now we shall code their Smart Contracts for MOOCs. Learning Objectives - Understand the tokenization of learning experiences. - Use the Inter Work Alliance Token Taxonomy Framework, IWA-TTF. - Apply IWA Token Designer to create Learning Tokens Templates. - Deploy them in Hyperledger Besu. - Understand granular learning interactions in MOOCs. - Explore simple ways to integrate Learning Tokens and MOOCs. Expected Outcome - Deploy Learning Tokens in Hyperledger Besu. - Report about connecting IWA-TTF to Hyperledger Beso - Explore alternatives to integrate Learning Tokens into MOOCs. - Report about possible alternatives to integrate Learning Tokens into MOOCs

TBA
Proposal

Automating Event Data Pipelines and Enhancing Discovery UX for DU Event Board

beginner
Open Science Labs•2026Varies90h (Small)

The DU Event Board currently uses manual inputs and basic validation to manage event data. As the number of events grows, this can make it harder to maintain consistency, avoid duplicate entries, and optimize API usage. Event discovery is also primarily based on simple filters and does not yet include offline access. This project improves how event data is processed and maintained. On the backend, it extends the existing GitHub Actions workflow to automatically fetch event metadata (image and description), detect duplicates using title and date similarity, and perform geocoding only once per event by writing coordinates back to the source file. These changes prevent duplicate entries, reduce repeated API calls, and remove the need for manual data fixes. On the frontend, the project adds full-text search, map-based filtering with a time slider, relative date display, and offline support. It also introduces a guided event submission flow that creates structured GitHub Issues, making it easier for contributors to add events. Together, these changes reduce manual review work and make it easier for users to search, filter, and access events.

pythonjavascriptc+++3
Student: Sanvi Shukla
Code

C/C++ Struct to ROS Message Converter

intermediate
Open Robotics•2025Varies175h (Medium)

This project aims to create a ROS2 package that automatically converts C/C++ structs into ROS2 messages and generates the corresponding TypeAdapters. This removes the need for developers to manually define message files or boilerplate conversion logic, making it easier to use C/C++ structures directly in ROS2. The package uses castxml to generate an abstract syntax tree, parse it with pygccxml, and extract c/c++ structs definations. Then, Jinja templates are used to generate ROS2 msg files and the corresponding Type Adapter from the parsed data. For opaque or external library types (e.g., Eigen), the system will support a mechanism to register custom TypeAdapters, allowing users to define conversion logic manually that can be included by other ROS2 packages. Deliverables: - Parser using castxml + pygccxml to extract struct definitions and a Jinja-based generator to produce ROS2 Message files and Type Adapters. - CMake macros/functions that can be used in ROS2 packages to register generated msg files to rosidl and install the type adapters. - Examples demonstrating usage of CMake functions/macros, auto-generated messages and type adapters in other packages.

pythonc/c++ros+5
Student: Himaj Joshi
Code
Proposal

A Flexible Grammar Mutator

advanced
afl++•2020Varies350h (Large)

<p>AFL++’s mutation engine is optimized for compact data formats, such as images, multimedia, compressed data. However, the current AFL++ does not support grammar and therefore struggles with highly-structured inputs like PHP, JavaScript, or HTML . Although AFL++ allows users to define a dictionary, including language keywords, to help generate inputs, it still lacks more structured descriptions of the underlying syntax.</p> <p>To tackle the existing limitations of AFL++, the main goal of this project is to develop a pluggable grammar mutator that is integrated with AFL++’s mutation engine and can efficiently generate grammar-aware inputs. On one hand, like Nautilus, we want to combine grammar mutators with AFL++’s mutation engine. Also, we want to avoid the potential limitation of Nautilus: “over time Nautilus de-generates to structure-unaware greybox fuzzing”, as indicated by AFLSmart paper. On the other hand, we want to generate test cases efficiently as F1 fuzzer. Furthermore, to improve usability, we will develop a program generator that takes the grammar model as input and generates a mutator library, which is based on AFL++’s custom mutator APIs.</p>

c/c++llvmfuzzing+2
Student: Shengtuo Hu
Code
Proposal

Volcano documentation & website revamp with Docusaurus (2026 Term 1)

Intermediate
•Varies175h (Medium)

The Volcano project currently uses Hugo for building its official website. However, current Hugo version of the website is pretty old and lacks modern features and flexibility, especially it is difficult to extend styles such as secondary menus, and there are problems such as invalid rendering of new markdown syntax. Docusaurus is a modern documentation framework that provides better support for versioning, localization, and theming. This mentorship focuses on modernizing the Volcano website by migrating it to Docusaurus, improving documentation structure, maintainability, and overall user experience. The project will involve replicating and enhancing the existing theme, restructuring documentation, improving navigation, and aligning the site with CNCF documentation best practices. The mentorship will also explore long-term maintainability and contributor-friendliness of the documentation workflow, especially to ensure that the documentation in the Volcano website is automatically synchronized with the documentation in Volcano's other code repos, using some automated tools like agents to keep the Volcano website up-to-date. - Expected Outcome: - Successful migration of the Volcano website from Hugo to Docusaurus - Improved documentation structure, navigation, and UX - A maintainable and contributor-friendly documentation setup - Clear contribution guidelines for future documentation updates

TBA
Proposal

GSoC'22 Processing Proposal (Teach Page)

beginner
Processing Foundation•2022$1.5k–$3.3k90h (Small)

【Idea of update the Teach Page】 1.Re-organize media from the teachers, code and video a)re-organize the resources with more detailed tags b) renew unreachable link and update the materials 2.Updating the contents and link to associated resource content based on two perspectives: Line to line explanation & Diagram the code 3.Grade by difficulty Two possible solutions: 1.Allow sharers to pre-set difficulty ratings when sharing and allow learners to reassess the difficulty of learning after participating or working through the material 2.The difficulty level is determined by comparing whether the functions used in different codes are more frequently used or not 【Deliverables】 Week 1-4 : Fit in & Beginner content update Week 5-6 : UI design Week 7-8 : Evaluation system in local environment Week 9 : Tag function in local environment Week 10-12: Final Teach Page 【After the Summer of Coding】 After GSoC'22, I will continue to be active on the p5.js GitHub and Processing Foundation's Discourse to answer Teach Page related questions. And I will also help maintain the Teach Page until GSoC'23.

pythonjavascriptandroid+6
Student: Gracia Zhang
Code
Proposal

Implementation of SBML-JSON converter and SBML-JSON scheme

intermediate
National Resource for Network Biology (NRNB)•2020Varies175h (Medium)

<p>The Systems Biology Markup Language (SBML) is the main language for representation and exchange of computational models in biology. JSON is the main data format of the web. Currently, many issues exist with the JSON representation of SBML used by tools like cobrapy, escher, ModelPolisher or the BiGG database.</p> <p>The idea of this project is to update the JSON scheme to have a full coverage of features important for constraint-based methods, i.e. SBML core and the additional SBML packages fbc and groups. In addition, existing issues related to SBML-JSON will be solved. The project will be implemented as part of cobrapy with main focus on the following:</p> <ol> <li>Annotation and meta-data support will be implemented</li> <li>Validation of JSON-SBML files will be performed</li> <li>Roundtripping SBML-JSON-SBML without information loss will be implemented</li> <li>JSON (SBML) scheme and scheme validation will be implemented</li> </ol> <p>Hence, a full-featured JSON exchange format for SBML will improve the web-integration and exchange of SBML models on web.</p>

pythonjavascriptjava+11
Student: Hemant
Code

Google Cloud IoT Core Interface in Lua

beginner
LabLua•2019Varies90h (Small)

<h5>The project consists of developing an interface, in Lua, for the set of Cloud IoT Core APIs, through two REST resources:</h5> <ul> <li>cloudiot methods, to facilitate device manager tasks</li> <li>cloudiotdevice methods, to facilitate device communication over the HTTP bridge </li> </ul> <h5>The Proof of Concept</h5> <ul> <li>Another task is to provide a Proof of Concept by using a real world device such as NodeMCU/Raspberry Pi interfaced with temperature sensor to send the temperature data over to the Google Cloud IoT Core. </li> <li>Doing the reverse, sending the data to the device using the Google Cloud IoT Core. We expect this data to be a Code Snippet, which would run dynamically on the device every time it is interrupted by the new code received.</li> </ul> <h5>Development of a software interface with REST support in Lua</h5> <ul> <li>With a minimal GUI this application will make the life of a person using Lua REST APIs easier by providing a simple interface to send and receive data from an endpoint.</li> <li>Testing would be done using the Proof of Concept developed above.</li> </ul>

luacéuelasticsearch+5
Student: Gaurav Kumar-1
Code
Proposal

DynamicFusion Implementation

intermediate
OpenCV•2019Varies175h (Medium)

<p>DynamicFusion is the first dense SLAM system capable of reconstructing non-rigidly deforming scenes in real time. It accomplishes this by extending the KinectFusion algorithm with a 6D motion field that is used to warp the canonical geometry onto the live frame. DynamicFusion was published by Newcombe, et al. and won the best paper award at CVPR.</p> <p>It tracks the evolution of a canonical geometry and has interesting applications in 3D scanning and augmented reality (AR).</p> <p>The algorithm consists of the following steps in a nutshell for each incoming frame:</p> <ol> <li>Estimation of the 6-dimensional motion field parameters using the ICP cost, which involves a data term as well as a regularisation term.</li> <li>Surface fusion of the received depth map with the canonical geometry after applying the estimated warp field</li> <li>New nodes are added in the warp field to cover newly discovered geometry and a regularisation graph, which is used to calculate the regularisation term in the ICP cost, is also updated.</li> </ol> <p>This project aims to bring a CPU-based implementation of the DynamicFusion algorithm to OpenCV as an extension of the rgbd module.</p>

pythonmachine learningc+++9
Student: Apoorv Goel
Code
Proposal

Community-Driven Docs for Deploying Microcks in Cloud Production (2025 Term 1)

Intermediate
•Varies175h (Medium)

Microcks (https://microcks.io/) is a cloud native, open source tool under CNCF for API and microservices mocking and testing. This project aims to support the growing Microcks adopter community by fostering a collaborative effort to document production-grade deployment strategies for cloud environments. While the core Microcks maintainers focus on features, security, and enhancements, the adopters are responsible for production setups. However, a shared repository of best practices can help users learn from one another in a true open-source spirit. This project will empower the community to deploy Microcks confidently in diverse cloud environments, fostering collaboration and sharing of expertise among adopters. Expected Outcome: Participants will contribute to the Microcks community repository (https://github.com/microcks/community/tree/main/install) by documenting deployment workflows for popular cloud providers, such as AWS, GCP, and Azure, as well as other providers like OVH, Oracle, Scaleway, or Koyeb. Deliverables will include guides on utilizing cloud-native services (e.g., PostgreSQL, MongoDB, IDP) to create robust and scalable Microcks installations ideally on managed Kubernetes services from the provider.

TBA
Proposal

SUSI Interpretation Project

beginner
FOSSASIA•2026Varies90h (Small)

This project aims to bring real-time, AI-powered live translation to the eventyay-video platform. Currently, the SUSI Translator prototype works well but relies on local computer microphones and standalone scripts. To make it ready for live online events, this project will upgrade it into a fast, web-native system that works entirely in the browser. The solution captures live audio directly from the speaker's browser, immediately filtering out silence to save server costs. This speech is then streamed at high speeds to a backend server. There, AI models (Whisper and an LLM) transcribe and translate the speech. To prevent robotic or broken grammar, the AI uses a "sliding window" to remember the last few spoken sentences, ensuring translations make sense in context. Finally, the translated text is sent back to the audience's screen as smooth, easy-to-read subtitles. Key Deliverables: - A browser-based audio capture and silence-filtering module. - A high-speed server connection (WebSockets) for instant data transfer. - A context-aware AI translation pipeline that prevents grammatical errors. - A stable, flicker-free subtitle interface built directly into the eventyay-video player.

pythonjavascriptandroid+7
Student: Eshaan Walia
Code
Proposal

Add Cluster API to Headlamp: Cluster lifecycle management UI (2026 Term 1)

Intermediate
•Varies175h (Medium)

Cluster API (CAPI) provides declarative APIs and tooling to provision, upgrade, and operate Kubernetes clusters. This project continues an existing Headlamp plugin to deliver first-class UI support for CAPI resources (Clusters, Machines, MachineDeployments, KubeadmControlPlanes). The plugin will let operators discover, inspect, and manage cluster lifecycle objects in Headlamp, visualizing hierarchical relationships and closing gaps in the plugin. Expected Outcome: - Sidebar and Map: List key CAPI CRs in the sidebar and Map view; show Clusters with Machines, MachineSets/Deployments, and control planes. - Resource details: Dedicated pages with CAPI-specific fields (conditions, infra refs, provider info, control plane refs, node pools, cluster membership, provider status). - UI integration: Map visualization, sidebar icons, on-hover "Glance" tooltips. - Robustness and tests: Fix runtime errors, human-friendly fields (e.g., "2d5h"), add automated tests. - Polish and delivery: Refined tables, icons, clickable "Controlled by" links; packaged in Headlamp’s plugin repo with install and developer docs; Kubernetes Blog post showcasing benefits.

TBA
Proposal
Showing 5689 - 5712 of 5976 Projects
236237238239240
Proposal
Proposal
Proposal
Proposal
Proposal