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.
Our website’s theming system, which allows individual chapters to customize the look of their websites, is due for a major overhaul. The site currently uses Bootstrap 2.3.2, which is over a decade old—the current version is 5.3. Bootstrap is used minimally (primarily for buttons and minor elements), and there are existing issues with color contrast. This project involves upgrading Bootstrap to the latest version, expanding its use throughout the website for standardized styling, and implementing Bootswatch themes as default customization options. Bootswatch would provides cohesive color sets, fonts, and other stylings that administrators could select and then tweak appropriately to work for their chapters.
There is no PDF renderer with Fully permissible licensing. Available PDF renderers are licensed under GPL licensing, which is pretty restrictive in terms of Open Source. Thus the new PDF rendering library i.e. libpdfrip, which is an extension of PDFio is to be the Fully permissible alternative to restrictive renderers.
CGAL's Basic Viewer provides one-call visualization of any CGAL data structure via draw(), but its OpenGL shader system has concrete user-facing bugs: edges disappear at certain zoom levels due to a numerically unstable inverse(u_Mvp) call in the geometry shader (#9292); edge width and vertex size are computed from the bounding box diagonal, producing hair-thin or geometry-obscuring results depending on object scale (#9327); 2D/3D camera transitions miscompute orthoCoef, breaking orthographic display (#5334); and the OpenGL < 4.3 compatibility path renders solid black (#6754, already fixed in my PR #9399). I will redesign the edge rendering pipeline to operate entirely in clip/NDC space, replace the bounding-box-based sizing with a viewport-relative pixel metric, fix camera transitions, add optional fragment-shader anti-aliasing, and produce a comparison report analyzing how MeshLab (VCGlib) and ParaView (VTK) solve wide-line rendering. I have already shipped three PRs into the Basic Viewer shader system and have 16 PRs on CGAL overall. Deliverables: robust clip-space edge shader, correct initial sizing, depth-correct edges, anti-aliased edges, updated OpenGL < 4.0 fallback path, MeshLab/ParaView comparison report, and regression tests. All changes backward-compatible with the existing draw() API.
Currently, the JavaScript engine Boa relies exclusively on a register-based interpreter, which limits its performance. This project proposes implementing the initial version of a Just-in-Time (JIT) compiler for Boa that operates alongside the existing interpreter. Specifically, the JIT compiler will be based on the copy-and-patch technique described by Xu and Kjolstad (2021) and implemented in python/cpython#113464. Unlike traditional JIT approaches that compile code at runtime, copy-and-patch generates executable code by copying precompiled machine code templates and patching them with runtime values such as stack variable offsets. This approach enables measurable performance improvements while avoiding extensive runtime overhead, which is important to Boa’s role as an embeddable engine. The primary goal of this project is to deliver the first JIT compiler for Boa. While only moderate immediate performance improvements are expected, the project aims to provide a solid foundation for future refinement and work toward higher execution speed.
This project focuses on improving the Ceph Dashboard by completing the migration from Bootstrap to the Carbon Design System and ensuring a consistent user experience across all components. Currently, the dashboard exists in a hybrid state with mixed UI frameworks, leading to inconsistencies, increased maintenance overhead, and a fragmented user experience. The proposed solution involves fully refactoring legacy UI components to Carbon, standardizing the frontend architecture using the lazy-loaded RoutedModule pattern, and replacing modal-based workflows with dedicated routed pages for better scalability and performance. Additionally, the project will address broken unit and end-to-end tests, expand test coverage for critical modules, and ensure long term stability through reliable CI validation. Key deliverables include a fully carbonized and consistent UI, improved application performance through modular routing and lazy loading, and a robust testing suite including unit and e2e tests covering previously untested areas. These improvements will enhance usability for end users, reduce technical debt, and make the codebase more maintainable and contributor-friendly.
The Haiku OS Devices application currently serves as a simple visualization utility for the hardware tree. This project will transform it into an interactive hardware control center, introducing features like blocking specific drivers, generating system compatibility reports and displaying information about the hardware itself.
This project focuses on implementing a cluster of high-priority features in Zulip across the message feed, compose box, and channel settings. In the compose box, it introduces reply-without-quoting, collapsed recipient pills for DM conversations, and auto-pillify on blur. In the message feed, it adds always-visible read receipts for DM conversations, multi-message deletion, a "New Messages" divider, move-by-recency for topics, and completes the zulip-icon-at-sign rollout to mention pills. In channel settings, it adds group-level unsubscribe for channels and shows inherited permissions as uneditable pills. The work builds on existing patterns in the Zulip codebase and focuses on shipping well-integrated, user-facing improvements across these areas.
GEARBOx is a clinical decision-support tool that helps clinicians match patients to open clinical trials but its current interface forces users to scroll through all eligibility fields responding to as many questions as possible, creating friction and slowing down the matching process. This project will transform that experience by replacing the long scrolling form with a typeahead search and dropdown with search, where clinicians can search and select only the fields they have data for. Additional enhancements include a category sidebar for direct section navigation across Demographics, Disease, Treatment & Exposure, Organ Function, and Biomarkers, and enhanced trial cards that surface blocking criteria at a glance — no extra clicks needed.
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.