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.
<p>Rucio produces large amounts of metadata for it’s files and datasets which is stored in a central Rucio server. However there is a fixed set of metadata attributes that can be stored currently. Rucio would like a generic metadata catalogue with no restriction on the kind of metadata stored for the files. The project is to to design and implement a generic and scalable metadata component that integrates with the core transactional model of Rucio.</p>
Debusine currently only shows task logs after a task has fully completed. This means developers working with long-running jobs (such as package builds or test pipelines) have no way to monitor progress in real time or catch failures early. This project adds live log streaming to Debusine. The implementation follows a four-stage pipeline. On the worker side, the sub-process runner will be extended to capture stdout and stderr incrementally as a task runs, sending each line to the server over the existing WebSocket connection rather than waiting for the task to finish. On the server side, a handler will receive these lines and write them to a per-task Redis Stream, providing a persistent, ordered, low-latency buffer that supports multiple simultaneous readers. A server-side view will then expose these log lines to browser clients via Server-Sent Events or a WebSocket endpoint. As a stretch goal, the Debusine web UI will subscribe to that endpoint and display lines appearing on the task page in real time, with no page refresh required. Deliverables: - Worker-side incremental log capture and WebSocket emission, with full test coverage - Server-side Redis Stream ingestion, per-task key namespacing, and post-task flush to PostgreSQL - A server view that streams log lines to browser clients for running tasks - A browser-side UI update that shows live output on the task detail page using plain JavaScript, without any frontend framework
Description: Cortex server has a simple authentication mechanism (X-Scope-OrgId) but users can’t use the multi tenancy features out of the box without complicated proxy configuration. It’s hard to support all the different authentication mechanisms used by different companies but plan to have a simple but opinionated auth-gateway that provides value out of the box. Expected Outcome: A new experimental cortex component called auth-gateway that validates tenants requests and proxies valid requests to distributors and query-frontend.
This proposal focuses on improving the Implementer Tools in OpenMRS 3 by addressing current limitations and adding key features. The project aims to support object editing in config fields, enable UI-based translation overrides, improve extension handling, and add privilege-based display conditions. It also proposes implementing Carbon React-based dark mode, a color picker for branding, server-side configuration saving, and fixing UI inconsistencies. These changes are aimed at making the tool more complete and easier to use for OpenMRS implementers.
The Jenkins website currently relies on Awestruct, an outdated static site generator, leading to maintenance challenges, inconsistent user experience, and missing versioned documentation. To address this, the project aims to migrate non-versioned content to Gatsby and versioned documentation to Antora. The solution includes modernising the UI/UX with shared React components, integrating Algolia search, maintaining SEO-friendly redirects, and automating builds for smoother contributions. Key deliverables include a full content migration, unified responsive design with a Jenkins theme, cross-version navigation, and a CI/CD pipeline for seamless deployments.
Proposed features to improve VideoCutTool's user experience on the Wikimedia website: 1) Cloud storage to save work, and resume editing from anywhere 2) Advanced editing features like special effects, transitions, and text overlays using FFPMEG commands 3) Keyboard shortcuts to speed up the editing process 4) Undo and redo functionality to revert changes and reduce risk of data loss 5) Unit testing with Jest, React testing library, and API mocking for error, internationalization, and cross-browser testing 6) Persisting edited video through local storage or server-side database.
<p>libModSecurity (aka ModSecurity v3) is a major rewrite of standalone ModSecurity (v2.x) which have high dependencies on 3rd party project including Apache. Now the project is splitted into two components namely connectors and core. Where the core is underlying library and connectors are the consumer of this library. This way ModSecurity cores becomes completely independent of underlying web server. In this project we will be extending the support of ModSecurity to Node.js by creating a ModSecurity connector for Node.js. This will provide ModSecurity support to a large community of Node.js developers as there are not many waf available in Node.js.</p>
The OpenMRS Authentication module supports powerful features like Multi-Factor Authentication and TOTP, but there is no working integration with the modern O3 frontend. When the backend issues a secondary authentication challenge, O3 has no way to handle it gracefully and will breaking the user's workflow and losing their unsaved work. My plan is to fix this on both sides. On the backend, I will update the backend to return structured JSON responses instead of legacy redirects, and expose new REST endpoints for TOTP setup and verification. On the frontend, I will update to pause and replay requests around authentication challenges, and build the React components that handle the TOTP flow that all without interrupting what the user was doing.
The Hyperledger Labs AIFAQ is an LLM ChatBot testable as a proof-of-concept. It replies to questions about Hyperledger standard documentation. The current version is a Google Colab Notebook which uses Gradio as GUI. This project proposes an implementation of a standard ChatBot GUI and the deployment of a prototype. Our end goal is to have a more usable system installed on a Cloud Server. Learning Objectives - Learn LLM background technology - Learn Javascript language and framework - Learn basics of Front-end development - Learn Cloud architecture and deployment - Learn how to create high quality documentation Expected Outcome and Deliverables - A Front-end component prototype - A simple container architecture - A good quality documentation
This project builds an AI-powered agent for KnowledgeSpace using Retrieval-Augmented Generation (RAG) to deliver precise, context-aware, and scientifically accurate answers. It combines Elasticsearch results with vector search (e.g., Vertex AI Vector Search) through an agentic system implemented in LangGraph, which orchestrates tool calls and fuses evidence for high-quality responses. The backend is a FastAPI service deployed on Google Cloud Platform with Vertex AI, and the frontend is a responsive React application. An automated update script regularly ingests new datasets and refreshes indices/embeddings to keep answers current. Together, these components streamline how neuroscientists explore and use complex neuroscience data.
KubeFlex is a flexible and scalable platform for running lightweight Kubernetes control plane APIs to support specific use-cases in cloud and edge computing environments. It supports various kinds of control planes, such as: vcluster, ocm, host, etc. This project aims to extend KubeFlex to support a new type of control plane that provides the full components of a control plane in a typical Kubernetes cluster (e.g., API Server, Scheduler, Controller-Manager, etc.). This new control plane will be based on K3s and it will allow KubeFlex to support new use-cases such as multi-tenant scenarios. Expected Outcome: A new type of KubeFlex provided control plane based on k3s
<p>The Authentication server of the litmus portal (which resides in the <code>litmus-portal</code> folder of the main litmus repository) is written in golang, uses certain outdated dependencies (such as mgo), and currently does not support third-party OAuth authentication modules such as:</p> <ul> <li>Google Authentication</li> <li>GitHub Authentication</li> <li>Local Authentication</li> </ul> <p>The current implementation of the authentication server also consumes more resources than the litmus portal’s GraphQL server.</p> <p>This proposal shall focus on re-writing the Authentication Module of the litmus-portal so that it achieves the following:</p> <ul> <li>The Authentication Module is Independent (Can be moved to a separate repository)</li> <li>The Module is light-weight and makes use of actively maintained dependencies (if any)</li> <li>The Authentication Server is robust and flexible to any future addition of features</li> <li>The Authentication Server supports OAuth authentication such as Google Auth and GitHub Auth</li> </ul>
This project aims to develop a plugin system for KubeStellar that will allow users to discover, install, and manage plugins that extend KubeStellar's functionality. The plugin system will provide a centralized hub for community-contributed plugins, enhancing KubeStellar's extensibility and user experience. The implementation will include a backend API written in Go and a frontend interface built with React. Expected Outcome: 1) A fully functional plugin system integrated into KubeStellar's UI 2) Backend API for plugin management (upload, discovery, installation, updates) 3) Frontend components for browsing, searching, and installing plugins 4) Plugin versioning and compatibility checking 5) User ratings and reviews for plugins 6) Documentation for plugin developers and users
Valhalla currently lacks a scalable way to detect routing and guidance regressions introduced by pull requests. This project builds a three-component QA system: a coverage-driven Python route generator that produces 10,000+ test routes over a static Switzerland OSM extract, exercising all costing models and routing-relevant OSM tag categories; a GitHub Actions pipeline that builds Valhalla graphs from both master and PR code, runs all routes against both, and computes geometry and instruction diffs; and a React review application - built inside valhalla/web-app, where maintainers can inspect diffs route by route, compare map geometry and turn-by-turn instructions side by side, and accept or flag changes before the baseline updates. The deliverable is a maintainer-usable, publicly deployed QA tool that makes routing drift visible and catchable at PR review time.
Visdom is great for watching training in real time, but once you have dozens of experiments, keeping track of what hyperparameters you used in each one becomes a mess. This project adds an experiment tracking layer to Visdom a SQLite-backed metadata store where every run carries structured hyperparameters, metrics, and tags. I am building a search system so you can query runs with simple syntax like "lr less than 0.01 and accuracy above 90", interactive parallel coordinates plots to visualize the hyperparameter space, and Optuna integration so Visdom can suggest what to try next based on past results. Everything runs locally with zero external dependencies, keeping Visdom's self-hosted philosophy intact. I have already contributed 6 PRs to the Visdom codebase covering backend bug fixes, frontend improvements, test fixes, and Python 3.12+ compatibility, and I have deep familiarity with both the Tornado server and the React frontend.
<p>Audio, video or data packets transmitted over a peer-connection can be lost, and experience varying amounts of network delay. Therefore, a web application like Jangouts, implementing WebRTC expects to monitor the performance of the underlying network and media pipeline. As a solution to this problem, I propose to integrate callstats.io into Jangouts. callstats.io is a SaaS service that helps WebRTC services detect and diagnose media and network quality issues. This project aims to give an option to companies and individuals deploying Jangouts to use this service in a user-friendly way. This task can be completed by sending WebRTC events and measurement data from the Jangouts application and the Janus media server in real-time to callstats.io. The idea is to integrate the callstats.io REST API with the WebRTC components in Jangouts and Janus. The Jangouts app will send endpoint stats and Janus will send the stats related to the WebRTC gateway.</p>
<p>In this proposal, I describe my plan to adapt Gatekeeper’s priority to the Linux kernel in context of traffic control and QoS. Gatekeeper is an open source defence against denial-of-service (DoS) attacks. To protect server resources from an attack, it services requests based on priority: the higher its priority, the closer to the exit of the egress queue its placed. Additionally, it also limits the requests’ maximum link bandwidth occupancy to 5%. Such countermeasures are implemented through the priority queue data structure which holds all requests in a single priority queue dropping low-priority requests when resources are low. This functionality allows us to allocate as many resources as possible to high-priority requests while servicing low-priority requests only when resources are idle. The successful implementation of this project will essentially enable a regular Linux router to help isolate and protect legitimate traffic during DoS attacks by employing Gatekeeper’s priority queue as a kernel module, enabled by its userspace component in Linux's tc(8) utility.</p>
<p>CrowdAlert practically addresses a really good problem we are trying build a solution for. It's solution boils down to having a robust and real-time end user experience.</p> <p>This proposal is about core optimisations and addition of new and exciting features to the user experience of the React application. That implies, using Server-side Rendering for faster page loading times (significantly low Time To First Byte), using web-sockets for real-time updates for incidents, comments and HTTP Long Polling for upvotes etc., migrating to more robust, scalable and available database solution, finally, decoupling it from Django views. Then we need to write consistent tests to validate different models and fields. Finally, an NFSW image classifier. Eventually, we will end up with cleaner code, sound application architecture of both frontend and backend, adding more tests and developing/revamping new features are the most obvious ones. This will not only make developing new features much more easier, cleaner and maintainable but will also dramatically improve user experience and take it to next level.</p>
A really common use case we have been seeing is about enabling an IoT scenario with MQTT based devices and using an Apache Kafka cluster as the events and storage platform running on Kubernetes via Strimzi. In order to do that, there is the need to map the MQTT protocol to the custom Apache Kafka one and bridge from one to the other. This project idea is about designing such a mapping and developing a pure [Netty](https://github.com/netty/netty/tree/4.1/codec-mqtt/src/main/java/io/netty/handler/codec/mqtt) based MQTT server component (not a full MQTT broker) able to accept MQTT client connections and handling the corresponding communication based on the [MQTT 3.1.1 specification](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html). Finally, developing the Kafka producer part to get messages from MQTT clients and sending them to an Apache Kafka cluster. - Expected outcome: POC source code for an MQTT to Apache Kafka bridge
<p>The <strong>Open Event</strong> Project offers event managers a platform to organize all kinds of events including concerts, conferences, summits and regular meetups. The various components support organizers in all stages from event planning to publishing, marketing and ticket sales. Automated web and mobile apps help attendees to get information easily.</p> <p>There are two major divisions of this project:</p> <ol> <li>Implementation of numerous features on the <strong>Open Event Server</strong> in order to make it feature complete. Some of the features that we aimed for were integration of <em>payment system</em>, <em>tickets</em>, <em>taxes</em>, <em>promo codes</em> etc. </li> <li>Integration of missing endpoints and related features on the <strong>Open Event Frontend</strong> and <strong>Open Event Orga</strong> app. Some of the features that we aimed for in the <em>frontend</em> were the implementation of <em>promo codes</em>, <em>notifications</em> while <em>tracks</em> and <em>speakers</em> endpoints were targeted for the orga app.</li> </ol>
<p>Jupyter project provides a way to perform scientific/mathematical computations with several different programming languages using the same user interface. It achieves that by distributing the processing between a front-end (Jupyter clients, like the web based Jupyter Notebook) and a back-end (Jupyter kernels, written in Python, R, Java, etc.), that communicate among themselves with standardized format messages, transmitted through ZeroMQ connection.</p> <p>Besides the ability to switch across different kernels from the same common interface, another advantage of this approach is the possibility to run the two software components on different machines, e.g., offloading the heavier backend processing to a remote server while sending commands and visualizing data from a mobile device running the frontend.</p> <p>For Scilab, there is currently a kernel that uses a compatibility layer with file access data exchange and numpy calls to communicate with clients through the Python reference implementation.</p> <p>This Google Summer of Code proposal aims to adapt or rewrite the current suboptimal solution, to make it a truly native kernel, linking ZeroMQ messages directly to Scilab API.</p>
<p>HTTP Load balancer is a software application capable of distributing HTTP traffic to backend servers according to the specified scheduling policy.</p> <p>WSO2 Gateway is a high performance, lightweight, low-latency messaging gateway based on standard gateway pattern. Its Netty based non-blocking IO and Disruptor (ringbuffer) architecture makes it the fastest open-source gateway available. Benchmarks shows that the performance of gateway is very high when compared to other solutions and is close to the direct netty based backend (without any intermediate gateway).</p> <p>The following features will be implemented:</p> <ul> <li>Support for different Load Balancing Algorithms</li> <li>Full Compliance with HTTP specification</li> <li>Support for SSL </li> <li>Session Persistence</li> <li>Health Checking and Redirection</li> </ul> <p>This Load Balancer will a pluggable component. It will be able to achieve even load distribution through highly efficient, lightweight and low latency messaging. Thus, the performance will also be able to compete with existing load balancers.</p>
<h3>User Profile App using ReactJS</h3> <p>As a part of modernising the architecture of DHIS 2, we are in the process of rewriting server based system maintenance apps as modern client side web apps. While development of settings app, maintenance app and app-management app is nearly complete, the User Profile App is yet to get started. As part of the GSOC 2016, I propose to develop user profile application for DHIS2. This app will essentially provide a user interface to DHIS2 users to -</p> <ul> <li>View and edit user profile details.</li> <li>View and edit user account settings.</li> </ul> <p>I will be using ReactJS view library and will follow a Flux based architecture to write this app. The application's architecture should be such that we can reuse most of its components in other apps using D2-UI. It is important that the overall look and feel of this app matches that of the other new client-side applications. D2 should be extended by adding methods and properties so that it is capable of performing all operations required to view and update user profile and account settings.</p>
As a final-year Software Engineering student at Kyiv Polytechnic Institute, I propose transforming Rucio WebUI into a more powerful, intuitive, and sustainable platform. Drawing from my previous contributions and technical expertise, I've developed a comprehensive strategy that addresses current limitations while setting the foundation for future growth. My plan focuses on migrating to modern technologies (Next.js 15, React 19, TailwindCSS 4.x), implementing server-side rendering for improved performance, enhancing the authentication system with NextAuth.js and RBAC, and fixing critical bugs like DID slash-handling issues and non-functional replicas loading. I'll also optimize performance through advanced streaming mechanisms for large data volumes, improve architecture with a transition to NX monorepo, enhance entity management functionalities, and implement comprehensive UI/UX refinements. With substantial experience in the Rucio WebUI codebase from my previous internship and 30+ contributions to the project, I've demonstrated my commitment and technical ability to execute this comprehensive modernization plan. My current work with Next.js and NX at a startup provides me with cutting-edge expertise that I can directly apply to enhance the project's development and implementation.