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

Support Floating Point Constraints for Path-Merged Regions

intermediate
The JPF team•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)

Java-Ranger is a path merging extension of Symbolic Pathfinder, that collapses multiple execution paths into a single region with a disjunctive constraint. Currently, it handles only integer constrains, which means, floating-point (FP) operations are either approximated unsoundly or cause solver errors. In this project, the aim is to add sound IEEE-754 floating-point support to Java ranger, enabling the correct summarization of regions containing FP arithmetic, comparisons, conversions, and library calls. The work heavily involves refactoring the underlying FP support in SPF (Modelling special values, rounding, comparisons, and conversions), then extending Java Ranger’s AST visitors, merging heuristics, and solver integration to handle the new FP constraints. The result will be an engine capable of analyzing FP-Java programs. Deliverables include: - New floating‑point expression nodes in the numeric package. - Updated bytecode handlers for all FP instructions. - Solver integration for Z3bitvector using the floating‑point theory. - Constant folding and simplification passes for FP expressions. - A test suite validating the correctness and coverage of FP handling. - Documentation of the new API and usage.

androidjavadistributed systems+2
Student: Salmane Khalili
Code
Proposal

PyDebeziumAI: Real-time CDC Integration for LangChain & LangGraph using Debezium

intermediate
JBoss Community•2026Varies175h (Medium)

Modern AI systems relying on Retrieval-Augmented Generation (RAG) often suffer from stale data due to batch-based updates. This project, PyDebeziumAI, aims to solve this by enabling real-time synchronization between databases and LLM pipelines using Debezium Change Data Capture (CDC). The project will extend pydbzengine to stream CDC events directly into LangChain and LangGraph by transforming database changes into semantic Document objects and updating vector stores in real time. Key deliverables include: - A Python library integrating Debezium with LangChain/LangGraph - Real-time vector store synchronization (Chroma, PGVector, Milvus) - Pluggable document transformation and ID strategies - End-to-end examples (RAG chatbot, reactive agent, dashboard) - Full documentation, testing, and PyPI release This will provide a production-ready bridge between CDC systems and AI frameworks, ensuring always up-to-date LLM context.

androidjavaide+12
Student: KMohnishM
Code

Mifos X Smart Contract & Loan Agreement Summarization with LLMs

intermediate
The Mifos Initiative•2026$3k–$6.6k175h (Medium)

Loan agreements are supposed to protect borrowers. In practice, most people sign them without understanding what they say, not because they're careless, but because these documents are written in language that takes training to parse. For the rural borrowers and small business owners that Mifos X was built to serve, this gap is not a minor inconvenience. It is a direct risk to their financial wellbeing. This project builds an LLM-powered summarization layer that integrates directly into Mifos X. A loan officer pastes a contract or pulls a loan product from Mifos X via the Fineract REST API, and the system extracts every key financial term like loan amount, interest rate, repayment schedule, every fee. It runs a mathematical consistency check on the numbers, and returns a plain-language summary written so anyone can understand it before they sign. Every extracted value is verified against the source text before reaching the screen, so the tool never silently surfaces wrong information. For MFIs with strict data privacy requirements, the system supports fully local inference via Ollama, no borrower data ever leaves their server. Before writing this proposal I built a working POC, deployed at https://loan-analyzer.streamlit.app/ , to prove the core pipeline actually works on real contracts. That POC is the foundation. The GSoC project takes it from a proof of concept into a properly integrated Mifos tool, with three deliverables: a working application connected to Mifos X with summaries generated in under ten seconds; a documented LLM evaluation comparing four providers on accuracy, readability, speed, and cost submitted to the Mifos wiki; and a clean codebase any contributor can clone and run in under fifteen minutes.

mysqljavascriptandroid+5
Student: Silky Vyas
Code

Observability Support for COCONUT-SVSM

intermediate
QEMU•2026Varies175h (Medium)

A guest operating system (OS), running inside a Confidential Virtual Machine (CVM), does not know the state information, such as log data or memory usage, of the secure module COCONUT-SVSM, which is responsible for managing the CVM. This information can be useful for the guest OS to understand the environment it is running in. A new protocol has been defined to enable the retrieval of this information. This project implements this observability protocol. The work is divided into several steps, which are also the deliverables: the implementation of a SVSM-side handler for the protocol, a guest-side handler, which is a Linux device driver, and a user-space tool, which uses the Linux device driver to retrieve and save the information.

cassemblykvm+4
Student: n-ramacciotti
Code
Proposal

NanoBSD Reimagined

intermediate
The FreeBSD Project•2026Varies175h (Medium)

NanoBSD has long provided a reliable framework for building embedded FreeBSD images, but its legacy pipeline remains monolithic and resource intensive, source based workflow. This project modernizes the NanoBSD image creation process by allowing decoupling of the build and assemble phases using pkgbase which is a package-driven assembly model. Furthermore by using tools like makefs, mtree, and mkimg, the new pipeline will enable fast, reproducible, and cross-architecture image generation without requiring root access. The key deliverables will include - PkgBase Integration into the current NanoBSD image creation pipeline, modernize the Boot support by implementing GPT layouts and UEFI booting for both x86 and aarch64 (ARM). The project will also focus on providing tier 1 support for Aarch64 devices. Also if time allows the support for ZFS filesystem will be added in the NanoBSD image with various eMMC storage optimizations to increase the life of those class of storages. Along with the support for automated first boot configuration will also be implemented using nuageinit.

c/c++llvmassembly+5
Student: Angshuman Sengupta
Code
Proposal

Editing of QTI Question types

intermediate
Learning Equality•2026Varies175h (Medium)

This project proposes to design and implement authoring support for six priority QTI 3.0 interaction types across the Studio stack. Every interaction this project produces will be renderable by any QTI-compliant platform.

pythonjavascriptdjango+1
Student: punhaniabhishek
Code
Proposal

Building a Full Print System Testing Pipeline

advanced
The Linux Foundation•2026Varies350h (Large)

Modern printer testing remains heavily dependent on physical hardware, making it slow, expensive, and difficult to scale for regression testing. While OpenPrinting already provides a Go-based MFP simulator and a Python-based image evaluation framework, these components are not yet integrated into a unified, automated testing system. This project proposes to build an end-to-end, hardware-free print testing pipeline that bridges this gap. The system will be implemented as a Go-based orchestration tool that directly leverages the simulator’s internal libraries for efficient control, while embedding Python to execute advanced image evaluation. It will automatically load printer models, create CUPS queues, enumerate all supported print modes, execute print jobs, capture simulator outputs, and evaluate them against expected results. The pipeline will support both single and batch testing modes, enabling scalable regression testing and seamless CI/CD integration. It will generate detailed, structured reports with quality metrics (e.g., SSIM, PSNR) and pass/fail analysis. By transforming isolated components into a cohesive, automated system, this project will significantly enhance reliability, reproducibility, and scalability of printer testing in the OpenPrinting ecosystem.

cpythonmysql+7
Student: arman01
Code
Proposal

OpenClaw Integration for Rocket.Chat

advanced
rocket.chat•2026Varies350h (Large)

OpenClaw is an open-source autonomous AI agent framework that allows users to run powerful local AI agents capable of executing complex tasks, using tools, and maintaining long-term memory. However, it currently lacks native integration with Rocket.Chat, a widely used open-source team collaboration platform. This project aims to bridge this gap by building a complete bidirectional integration between OpenClaw and Rocket.Chat. Users will be able to interact with OpenClaw agents directly within Rocket.Chat channels and direct messages, enabling seamless automation, task execution, and proactive responses inside their familiar workspace. I plan to develop a robust Rocket.Chat adapter/plugin that includes bot user creation, REST API integration, incoming and outgoing webhook support, secure authentication, and reliable message handling. Key Deliverables: Production ready OpenClaw plugin for Rocket.Chat Full support for direct messages and public/private channels Smooth sending and receiving of messages with OpenClaw agents Proper configuration support in openclaw.json Comprehensive documentation and setup guide Upon completion, Rocket.Chat users will be able to harness the power of autonomous AI agents for tasks like security audits, reminders, code assistance, and custom workflows directly from within Rocket.Chat.

javascriptwebrtcmeteor.js+18
Student: Kartik Doda
Code
Proposal

FinBot CTF: A Pluggable Guardrail Framework & MCP-Based Defense Scenario Pack

intermediate
OWASP Foundation•2026Varies175h (Medium)

FinBot CTF is OWASP's premier learning environment for agentic AI security, yet it currently operates solely as an offensive arena. Practitioners can exploit vulnerabilities but lack the capability to implement, test, and score defenses against the OWASP Agentic Top 10. This project closes the blue-team loop by introducing a production-inspired, hook-based security framework. The solution is a four-part architecture: (A) a pluggable Guardrail & Detection Framework with pre-tool, post-output, and pre-action hooks that emit a standardized security event model; (B) a Defense-Enabled Challenge Pack converting 3-5 existing offensive challenges (A2: Excessive Agency, A3: Memory Poisoning, A8: System Prompt Leakage) into paired red/blue tracks with integrated defensive scoring; (C) an MCP-Style Scenario Module featuring benign and malicious JSON-RPC tool servers, with detectors for output poisoning, prompt injection via payload, and unauthorized endpoint redirects; and (D) comprehensive Documentation & CI including Docker Compose, contributor guides, and a GitHub Actions test suite. This work transforms FinBot into a complete AI security training platform. Leveraging my prior contributions to the codebase, I will deliver a low-risk, high-impact implementation that equips defenders to build, test, and validate guardrails against real-world agentic threats, solidifying FinBot's role as the practical counterpart to the OWASP Agentic Top 10.

pythonjavascriptjava+10
Student: Regis MUKIZA
Code

Add packaging options to RTEMS Deployment.

intermediate
RTEMS Project•2026Varies175h (Medium)

RTEMS Deployment currently supports TAR and RPM package types for toolchain and RTEMS BSP configuration distributions. However, users of Debian-based Linux distributions and FreeBSD must currently use TAR packages, which cannot track dependencies, upgrades, or clean removals like a real package manager. This project will provide native packaging support for Debian (.deb) and FreeBSD (pkg) package types within RTEMS Deployment. A packaging abstraction will be implemented in Python and will be shared between both packaging backends by refactoring the existing RPM backend. This will provide a clean integration with our current deployment model. This will provide RTEMS toolchain installation and management support for developers using Debian, Ubuntu, and FreeBSD distributions with their native package managers. It will also provide integration tests, documentation, and a tutorial for future contributors to easily integrate other package types into RTEMS Deployment.

cpythonembedded systems+5
Student: Ayush Yadav (acidicneko)
Code
Proposal

Building a Multi-Provider SMART on FHIR Backend for Patient Health Record Access

intermediate
Data for the Common Good•2026Varies175h (Medium)

D4CG's SMART on FHIR application gives patients autonomy over their Electronic Health Records, enabling them to share records with researchers. The current backend supports only Epic's sandbox environment, discards OAuth tokens after exchange, and uses in-memory state management that cannot scale. This project builds a production-ready multi-provider backend that supports Epic, Cerner, and any generic SMART-compliant provider. It replaces the current in-memory architecture with database-backed token persistence, adds enhanced provider search via the ONC Lantern registry, and delivers a tested, documented, and containerized API.

pythonjavascriptkubernetes+2
Student: Philip Narteh
Code
Proposal

NeuroHealth-Vision: A Volumetric Perception Module for Multimodal Clinical Reasoning

advanced
UC OSPO•2026Varies350h (Large)

The NeuroHealth-Vision project aims to bridge the "Protocol Gap" in 3D medical AI by developing a standardized evaluation and transfer-learning framework for volumetric foundation models (VFMs). While current generalist models excel in common thoracic or abdominal tasks, they often struggle with specialized clinical protocols involving unique acquisition physics and contrast kinetics. This project will systematically benchmark frontier architectures (like CT-FM, etc.) across various unseen specialty downstream tasks using zero-shot, few-shot, and Parameter-Efficient Fine-Tuning (PEFT) methodologies. Deliverables include open-source preprocessing pipelines for 3D volumetric normalization and spatial alignment, alongside optimized model weights and a comprehensive benchmarking report. This work will ultimately provide the multimodal "perception engine" for the broader NeuroHealth clinical assistant, enabling it to integrate high-dimensional imaging data into its diagnostic reasoning core.

pythonc/c++visualization+5
Student: Antonio T.
Code

KStars AI Powered Guiding Assistant for Ekos

advanced
KDE Community•2026Varies350h (Large)

The AI-Powered Guiding Assistant replaces the steep learning curve of manual astrophotography guiding with a predictive, mount specific machine learning model. This project augments KStars' reactive PID controllers by utilizing an offline trained Gated Recurrent Unit (GRU) to automatically learn and counteract complex mechanical errors like gear backlash, harmonic drive signatures, and wind disturbances in real time. To ensure maximum performance on low power embedded devices like the Astroberry, the project features a native C++ inference engine built entirely from scratch using lightweight Eigen3 matrix math. This guarantees highly accurate, intelligent pulse augmentation with an absolute minimal memory footprint and without any big ML dependencies linked into the KStars ecosystem.

c/c++qtqml+6
Student: Pavan Kumar S G
Code
Proposal

Linux Livepatching

intermediate
Debian•2026Varies175h (Medium)

Linux Kernel Livepatching is the process of replacing functions in the kernel code affected by CVEs with the patch-applied functions during system runtime. It's basically a method to apply security kernel patches to a running system such as a server without rebooting it. Such a feature is crucial for servers running crucial computational tasks 24/7 which cannot afford a reboot. Livepatch module is already provided by the Linux kernel but it's upto the distributions as to how they will be handled. As of 2026, only a few handful amount of distributions like SUSE, Ubuntu and RedHat offer Linux livepatches, which means no community maintained distribution at the moment offers Linux livepatches. There has been a way to utilise Linux livepatching in Debian in the past using kpatch but after the release of Debian 13 Trixie, the support for the kernel in kpatch has been dropped which halted the progress of supporting livepatching in Debian. klp-build is a promising approach to this problem but it only supports SUSE kernels which are only accessible by internal SUSE employees. Debian also lacks a release plan or mechanism to distribute livepatches for kernels. The goal of this proposal is to introduce Linux livepatching in Debian by studying how livepatches can be integrated into Debian and if existing technologies like clang-extract can be integrated into the workflow, forking klp-build to develop dlp-build which will serve as a tool to create livepatches for Debian kernels, as well as proposing a binary format for livepatches and designing a release cycle for the same.

pythonjavascriptc/c+++8
Student: Aryan Karamtoth
Code
Proposal

Per List Backup and Restore

intermediate
GNU Mailman•2026Varies175h (Medium)

Mailman 3 has no way to back up or restore a single mailing list. If a list is accidentally deleted or a database migration goes wrong, there is no recovery path. This project builds one: two CLI commands: mailman backup and mailman restore, backed by a schema-validated JSON export format. The backup captures all list state: 85 config fields, member roster across all three roles, header-match rules, aliases, bans, and archiver states. Restore validates the file against a JSON Schema before touching the database, guards against missing domains, preserves verified_on exactly, and uses an is_subscribed() pre-check to avoid SQLAlchemy session poisoning. The operation is silent so no welcome or verification emails are triggered.

pythondjangoemail+4
Student: Navya Khanna
Code
Proposal

Updating and Extending the ecotourism Package for Teaching and Wildlife Trip Planning

intermediate
R project for statistical computing•2026$3k–$6.6k175h (Medium)

This proposal aims to extend the ecotourism R package developed during GSoC 2025 by updating the tourism data to include most of 2025, creating classroom-ready teaching materials, and designing a deployed Shiny app for wildlife exploration across Australia. The project will strengthen the package as both a teaching resource and a practical exploration tool by integrating wildlife occurrence, tourism, and weather data into a more complete and accessible workflow. The proposed work aligns closely with the 2026 project brief: update the package data, develop teaching materials for data science and statistics units, and design, implement, and deploy a Shiny app that helps users learn about the best locations and times to spot wildlife across Australia. The project also builds naturally on my GSoC 2025 contribution to ecotourism, which gives me direct familiarity with the package structure, data sources, and mentor expectations.

cc++r+4
Student: Javad Vahdat Atashgah
Code

Canadian OLAP Integrated Database

advanced
Open Food Facts•2026Varies350h (Large)

The Open Food Facts (OFF) Canada database contains information about branded food products, including their ingredients and nutritional values. This data acts as an integral part for several OFF applications, such as the recipe extension, search page extension, product page extension, and online store extension, which helps in answering user queries about food products. For these applications to respond efficiently, the underlying database must be highly performant and reliable. However, the current database contains inconsistent and incomplete data, which limits its effectiveness for analytics and query performance. The goal of this project is to design and implement an OLAP database by integrating recipe and food product data. This will involve building an ELT pipeline to clean, standardize, and augment the data so that both developers and users can retrieve insights quickly and reliably.

androidmachine learningmongodb+6
Student: Ramya Sanjana
Code
Proposal

Integrating Empirical Dynamic Modeling (EDM) into the Fisheries Integrated Modeling System (FIMS)

beginner
IOOS•2026Varies90h (Small)

This project proposes the integration of Empirical Dynamic Modeling (EDM) into the Fisheries Integrated Modeling System (FIMS), an open-source framework used for fisheries stock assessment. While FIMS currently supports parametric models such as catch-at-age and surplus production models, ecological systems often exhibit nonlinear dynamics that are difficult to capture with predefined equations. EDM offers a data-driven alternative that reconstructs system dynamics directly from time-series observations using delay embedding techniques. The project will implement core EDM components within FIMS, including delay-embedding generation and prediction algorithms such as Simplex projection, S-map, and Gaussian Process EDM. These methods will be integrated with the existing FIMS statistical inference framework to enable empirical forecasting and hybrid modeling approaches. The final outcome will be a modular EDM module, tested using GoogleTest and testthat, along with documentation and example workflows to demonstrate its application in fisheries modeling.

pythonocean sciencejava+3
Student: aman-raj-srivastva
Code

GGUF Reader V2 in OpenVINO GenAI for Direct GGUF Execution via Dynamic Graph Translation

intermediate
OpenVINO Toolkit•2026Varies175h (Medium)

The current GGUF reader in OpenVINO GenAI manually reconstructs model architectures by parsing metadata and building the OpenVINO model layer by layer — requiring explicit C++ implementations for every supported model topology. This project implements GGUFReaderV2, a new GGUF reader that uses dynamic graph translation instead. It leverages llama.cpp APIs to produce a GGML computation graph (ggml_cgraph), passes it through the existing GgmlOvDecoder and ov::frontend::ggml::FrontEnd infrastructure to produce an ov::Model, and integrates the result into OpenVINO GenAI's read_model() pipeline. A working prototype has already been validated with TinyLlama.gguf — successfully capturing 5,141 OpenVINO operations and executing them through the translation pipeline. Key architectural challenges around tensor naming, capture state safety, and test design have been identified and documented. Deliverables: 1. Functional GGUFReaderV2 class with correct RAII resource management and passing math equivalence tests 2. Stable GGML to OpenVINO graph translation with collision-free node mapping 3. Full integration into GenAI's read_model() API with dynamic shape support 4. Regression test suite validating accuracy across quantization formats (Q4_K, Q6_K, Q8_0) and architectures (TinyLlama, Phi-3, Llama-3, Qwen2.5) 5. Comprehensive documentation and developer guide for extending GGML operator support

pythonc++x86+1
Student: KARNAV SHAH
Code

Improve Robustness of Poisson Solver

intermediate
QC-Devs•2026Varies175h (Medium)

The grid library evaluates the Coulomb potential of molecules by numerically solving Poisson's equation. However, true electron densities possess sharp, infinite slope cusps at atomic nuclei. These physical singularities cause the existing numerical Initial Value Problem (IVP) and Boundary Value Problem (BVP) solvers to suffer from catastrophic instability and convergence failures. This project solves this by implementing a "Double-Split-Plus-Solve" architecture. Instead of forcing numerical solvers to handle the singularities, this strategy uses the BFit library and AtomDB to analytically fit and extract the sharp promolecular atomic cores and bulk bonding densities using Gaussians. Because Gaussians have exact analytical potentials, we calculate the potential of the cusps with zero numerical error. This leaves only a tiny, perfectly smooth residual density for grid's numerical BVP solver to integrate, allowing it to converge rapidly and accurately without crashing.

pythongithubc+++2
Student: Aochuba S Aier
Code
Proposal

Website Modernization Migration from Jekyll to Hugo

intermediate
preCICE•2026Varies175h (Medium)

The preCICE website is built on Jekyll with several Ruby gems that have become difficult to maintain (many of which have been abandoned) and cause frequent build failures for contributors. The goal is to move the site to Hugo (a static site generator built on Go), which handles most of what these plugins do out of the box. This means porting layouts from Liquid to Go templates, upgrading from Bootstrap 3.3.7 to Bootstrap 5, and restructuring content to fit Hugo's model. All existing URLs and external documentation integrations will be kept intact during the transition. Deliverables include a fully functional Hugo site, rewritten CI/CD workflows, Algolia search via JSON output, and sub-repo mounts replacing Jekyll submodules. By the end, any contributor should be able to clone the repo and build the site in one command, with no Ruby setup required.

cpythonshell+1
Student: Aashir
Code
Proposal

New Users Anti Spammer System

intermediate
rocket.chat•2026Varies175h (Medium)

Open Rocket.Chat communities face a growing problem where new accounts join, flood multiple public channels with spam, and disappear before any moderator can respond. Current moderation is entirely reactive and manual, which is simply too slow for coordinated spam campaigns. This project builds a proactive, human-validated anti-spam system that monitors new users during their first 6 to 10 weeks and responds through a graduated restriction system called Moderation Levels, where every action is proportional, reversible, and requires admin approval before anything permanent happens. The system is built as a Rocket.Chat App on the Apps Engine with a seven gate detection pipeline running entirely in memory for speed. Gates catch exact duplicates via hash matching, polymorphic spam via cosine similarity, cross channel floods, rate flooding, rapid room spread, and phishing link campaigns. A four tier Moderation Level system escalates naturally with repeat behavior, from a friendly DM warning through posting cool downs to a permanent block that only lifts when an admin vouches for the user. The admin control layer includes a live dashboard, a full slash command suite, and AI powered on demand summaries so admins have everything they need to make confident moderation decisions without opening a single log file. Deliverables include a fully functional installable Rocket.Chat App covering the complete detection pipeline, a configurable Moderation Level system, a behavioral scoring engine, enriched admin notifications with message history, AI powered user analysis commands, a paginated admin dashboard built for scale, daily scheduled reporting, and complete documentation covering architecture, configuration, and known limitations.

javascriptwebrtcmeteor.js+18
Student: Meet.jain
Code
Proposal

Lua Script Test Harness: A Standalone CLI Tool

intermediate
VideoLAN•2026Varies175h (Medium)

VLC uses lua scripts for tasks like playlist parsing, service discovery, and art fetching. Currently, testing these scripts requires manually running the full VLC application. This is inefficient and fails to catch bugs when external websites change their markup, leaving scripts broken. This project builds a standalone CLI test harness (vlc-lua-mock) that replicates the VLC Lua engine's behavior without requiring a VLC build. It uses mock backends and stubs for VLC Lua bindings, supports both behavior and state assertions, and includes a recording mode for fixtures.

copenglc+++10
Student: Bipul Lamsal
Code
Proposal

EmbeddedChat 2026: Modernize APIs, Enable Matrix Federation, Add Pluggable AI, and Improve Mobile UX

intermediate
rocket.chat•2026Varies175h (Medium)

EmbeddedChat is Rocket.Chat's embeddable chat widget, but RC 8.x broke several core endpoints, Matrix federation support is absent, there is no AI extensibility point, mobile responsiveness is inconsistent, and WCAG compliance is incomplete. This project restores RC 8.x compatibility and completes the DDP client migration, adds production-ready Matrix federation via a mode prop backed by an upstream RC core fix, introduces a standalone provider-agnostic AI adapter package, systematically fixes mobile viewport issues, and brings the widget to WCAG 2.1 AA compliance. Working POCs exist for all five goals

javascriptwebrtcmeteor.js+18
Student: Aryan69
Code
Proposal
Showing 337 - 360 of 11996 Projects
1314151617
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal