Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
Work on making the Firefox web browser more accessible for users with disabilities. Implement new WAI-ARIA standards and screen reader compatibility fixes. (Outreachy Project)
The Wi-Fi drivers has been changed to support newer protocols. So all existing wifi drivers needs to be changed and reworked to the new code base. Some of them are already converted and tested but some of them are not yet converted and tested on the real hardware. I am going to convert and test (otus -- Atheros USB IEEE 802.11a/g/n wireless network device (https://man.netbsd.org/otus.4) on TP-Link TL-WN821N which is a compatible device for this driver.
This project introduces native per-character text animation support in Synfig. Currently, text is rendered as a single shape, making effects like staggered animation, typewriter effects, or per-letter transforms difficult without workarounds. The proposed solution decomposes text into glyph-level elements and enables independent animation of position, rotation, scale, color, and opacity for each character. A reusable stagger engine will be implemented to support delayed animations across characters, with a design that can be extended to general group-based animation in the future. The project will deliver new layer types for glyph-based rendering, full integration with Synfig’s animation system, UI support, file format compatibility, and user documentation.
Currently, Bluetooth HID support in FreeBSD is limited to the bthidd daemon. The daemon, while functional, uses its own custom userspace drivers rather than the existing HID drivers in the kernel. Of these userspace drivers, only keyboards and mice are supported. This project proposes a more integrated design via a new Netgraph node type: ng_bthid. This node will hook to ng_l2cap and function as a virtual transport layer that interfaces directly with hidbus. The aim is to make HID support more transport-agnostic, moving away from the previous approach of maintaining separate, redundant drivers for devices over Bluetooth.
The current CGAL Python bindings expose powerful computational geometry algorithms, but they've accumulated real usability problems: method parameters show up as arg0, arg1, arg2 rather than meaningful names, docstrings are either absent or embedded so deeply inside binding code that they obscure the logic itself, CGAL's Named Parameters system isn't available from Python at all, and the CI pipeline isn't running. More critically, I found and documented 7 crash scenarios where Python objects outlive freed C++ DCEL memory → situations that kill the interpreter with a segfault instead of raising a Python exception. Over the past three months I've been working directly in the codebase building the foundation for this project. I've added nb::arg() parameter names to AOS2 binding methods, written inline docstrings following CGAL's own documentation style, built a 7-flag CMake check system aligned 1:1 with CGAL's macro structure, and validated a working 8-kernel CI pipeline before this proposal was even submitted. I've also worked through the Named Parameters challenge far enough to identify the property map type-bridge problem → the part that makes Weeks 7–8 genuinely hard. The deliverables for the 12-week program are: complete named parameter coverage across AOS2 binding files, full docstring coverage for AOS2 methods, 7 CGAL-aligned CMake precondition flags with fixes contributed upstream to CGAL C++, Python-accessible Named Parameters for key PMP functions (compute_vertex_normals, smooth_mesh, triangulate_faces), bindings for at least one currently unbounded package, and a production-ready 8-kernel CI pipeline with integrated test coverage.
Every time a researcher wants to train a language model, they end up rewriting the same infrastructure: data loading, optimizer setup, training loops, logging, and checkpointing. PyTorch-Ignite solves the engine abstraction, but researchers still have to manually wire everything together for each new experiment. Trainite is a pip-installable Python toolbox built on top of PyTorch-Ignite that handles this. A single trainite init command gives researchers a complete, runnable training project. They bring their model and dataset, and Trainite handles the rest. Deliverables include an installable package, a CLI scaffolding tool, a working end-to-end training pipeline with a built-in Transformer example, YAML-based configuration, organized timestamped outputs, full documentation, and tests.
Enlightenment desktop is a low on resources desktop environment without sacrificing on visuals. NetBSD support for this desktop has been left a few versions behind. The aim of this project is to port the newest version of the desktop to pkgsrc and commit upstream portability fixes when necessary to ease future versions updates for NetBSD. The project will also investigate and maybe port the Moksha desktop environment, which is a fork of an older version of Enlightenment desktop before a major rewrite happened in the project.
Teachers cannot assign, collect, or grade App Inventor projects through their LMS. They share project links manually, collect screenshots, and enter grades by hand. This project builds a Google Classroom integration so teachers can create assignments linked to template projects, students can submit completed projects to Classroom, and teachers can return grades without leaving their normal workflow. The backend introduces an LmsService interface so that adding Canvas or Moodle support later requires only a new provider class. Deliverables are tiered: minimum (OAuth2 plus course listing plus assignment creation), target (full create-distribute-submit lifecycle with error handling), and stretch (GWT UI plus grade passback plus integration tests).
The Zulip community has been actively requesting improvements to video call functionality and Atlassian integrations, and addressing this cluster of features would meaningfully expand Zulip's appeal for organizations that depend on these tools. On the video call side, I will implement a Google Meet provider, help take a native LiveKit integration prototype to a mergeable state, build a cold-call ringing experience and add support for multiple simultaneous video call providers per organisation. On the Atlassian side, I will implement a bidirectional Jira integration extending the existing webhook with richer filterable notifications and outbound actions (comment, assign, change priority) directly from Zulip, and a new Confluence incoming webhook integration covering the full page and blog lifecycle. All deliverables include full test coverage, API documentation, changelog entries, and help center articles. The work builds directly on my existing merged and open PRs in Zulip's video call and Atlassian integration areas.
Currently, while kpt is a highly capable tool for declarative Kubernetes management, its official examples rely heavily on complex, specialized domains like telecommunications. This creates a high barrier to entry for standard developers trying to learn the "configuration-as-data" approach. This project solves that problem by providing a universally understood example. I will package the popular "Online Boutique" (or a similar application) microservices application into a complete, modular kpt package. Using this baseline, I will build and thoroughly document four practical customization workflows: Changing the store theme (e.g., adapting the boutique into a florist or car accessory site). Localizing language and currency settings. Configuring regional Sales Tax and VAT. Adjusting deployment configurations for Small, Medium, and Large scales. etc.. Ultimately, this project is an opportunity for me to deeply learn and demonstrate how kpt handles complex mutations without relying on traditional templating tools like Helm. The final deliverable will be a production-grade package contributed directly to the CNCF kpt toolchain, making the platform significantly more accessible to new users in the open-source community.
Bio-Block is an open-source healthcare data marketplace on Ethereum and IPFS that handles the full upload → anonymize → encrypt → sell → download lifecycle. However, the pipeline stops at download — once a buyer purchases and decrypts a dataset, there is no way to analyze it inside Bio-Block. This project adds a data analytics layer by introducing a dedicated FastAPI Analytics API (port 3003), a lightweight AnalyticsRegistry smart contract for on-chain result tracking, and a React dashboard for visualizations. The system supports three levels of analysis: graphical (distribution plots, heatmaps, scatter plots via matplotlib/plotly), descriptive (summary statistics, correlation matrices via pandas), and inferential (t-tests, chi-square, ANOVA via scipy/statsmodels). Results are stored on IPFS and linked to their source datasets on-chain via the AnalyticsRegistry contract, maintaining an unbroken chain of custody from data purchase through analysis. Deliverables include: (1) Analytics API microservice with EIP-712 authentication, (2) AnalyticsRegistry.sol smart contract deployed on Sepolia, (3) IPFS result storage and on-chain attestation pipeline, (4) Interactive React analytics dashboard integrated into the existing frontend, (5) Comprehensive test suite (80%+ coverage) and documentation. An optional differential privacy layer using OpenDP is planned as a stretch goal.
Integrating AI agents with databases today requires custom implementations for each framework—no standard exists for capability discovery, safe query execution, or persistent context across sessions. This project adds agent compatibility to Apache AsterixDB by implementing two emerging standards: the Model Context Protocol (MCP) for structured tool exposure and the Agent-to-Agent (A2A) protocol for multi-agent coordination, along with persistent agentic memory utilizing AsterixDB's native storage. Key deliverables include: McpServlet implementing JSON-RPC 2.0 protocol with tools/list, tools/call, and resources/read methods; ToolRegistry enabling dynamic capability discovery; QueryTool and SchemaTool exposing SQL++ execution and dataset introspection; rate limiting and query safeguards for production safety; AgentMemoryManager providing durable CRUD storage for session context via SQL++ datasets; MemoryServlet REST endpoints for memory operations; and A2A protocol endpoints for multi-agent task delegation (stretch goal). The implementation integrates with existing AsterixDB infrastructure—BasicAuthServlet for authentication, MetadataManager for schema access, and LSM storage for persistence—requiring no breaking changes. By project end, AI agents can discover AsterixDB's capabilities, execute queries like "find customers with orders over $1000," and recall previous interactions across sessions—transforming AsterixDB into an AI-native database that speaks the language of modern agent frameworks.
FinBot CTF has no defensive layer, players can exploit agentic AI vulnerabilities but can't learn to stop them. This project fixes that gap. I'll build a GuardrailEngine that intercepts agent actions before execution, convert 4 existing challenges into paired red/blue scenarios with OWASP Agentic Top 10 and MITRE ATLAS mappings, and develop a stateful MaliciousToolServer that simulates real supply-chain attacks. Deliverables: GuardrailEngine with 4 built-in policies, defense-enabled scenarios for Puppet Master, Invoice Trust Override, Fine Print, and RCE via SystemUtils, two new supply-chain challenges (Shadow Protocol + Trojan Invoice), and full CI/CD with contributor documentation. The result is a complete attack-and-defend environment, the only hands-on platform purpose-built for agentic AI security.
The holidays library currently embeds translated holiday names directly within country-specific Python modules, causing significant data redundancy and high barriers for non-developer translators. This project introduces a centralized, Gettext-based architecture that extracts these strings into dedicated .po files one per language loaded lazily at runtime. How I plan to solve it Develop an AST-powered extraction script to identify all self.tr() calls across 100+ country modules. Implement a LocaleRegistry class to manage lazy loading and en_US fallback logic. Migrate the existing codebase to this decoupled architecture to enable easier integration with tools like Weblate. Key Deliverables: A Python CLI utility for automated string extraction. A centralized /holidays/locale/ directory structure. A fully integrated LocaleRegistry with backward compatibility support. A "Translation Contributor’s Guide" for future community volunteers.
This project aims to optimize the performance and scalability of many code paths in Zulip, with a focus on performance sensitive code paths like Zulip major endpoints which have request volume and cost that makes them important. The project also aims to design and implement a new feature of “LLM conversation summary”, and includes fixing issues in other areas.
This project aims to complete and productionize the FOSSology UI by finalizing the ongoing migration to Next.js and ensuring full integration with REST API v2. Building on the previous GSoC work, the project focuses on implementing the remaining pages, standardizing the interface using a reusable design system with ShadCN and Tailwind CSS, and improving overall consistency, accessibility, and user experience. The application will be upgraded to the latest Next.js version to leverage advancements in performance, caching, and rendering. Additionally, the project will emphasize modular architecture, component reusability, and comprehensive Storybook documentation. Thorough testing, codebase refactoring, and detailed developer and user documentation will be completed to ensure scalability, maintainability, and ease of future contributions.
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.
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.
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.
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.
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.
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.
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.
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.