Explore Projects

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.

InZpect is next generation dump viewer and inspector that is something of a successor to IPCS. There is a lot of work to do in UI and testing. Plus almost any work on the internals requires lots of knowledge of the operating system. SVCDumps are not highly structured, so the relationships of data and state of the computation must be synthesized from the memory blocks in the dump, primarily. The server is written in java, with some back-end code coming from extensions/usage of the ZSS in Zowe. The client code is in Javascript using React. The tooling is very minimal currently, as is the number of third-party libraries.

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.

<p>Rivet is a software package for performing data analysis on simulated particle collision events like those in the Large Hadron Collider. This project will focus on making Rivet performant on modern CPU architectures in HEP and HPC compute facilities, particularly ensuring that the central result caching and dispatching system is thread-safe and amenable to vectorized compiler optimizations. We will be working to Improve the Rivet's computational performance, make it thread-safe, profile and optimize the expensive computational components and ensure continuity of physics behaviour via the Gitlab CI engine.</p>

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 12 Factor Application project is a methodology for building and deploying scalable, maintainable, and suitable software applications. The project is based on 12 key principles that outline best practices for developing and deploying software applications. Project Goals are : 1. Make CircuitVerse a 12 factor application. 2. Progressively convert CircuitVerse previews and profile avatars to object storage. 3. Improve observability using OpenTelemetry. 4. Drop visitor tracking by storing user details and adopt HyperLogLog for project view count. 5. Zero downtime deployment pipeline with GitHub Actions and Kamal. 6. Monitoring server with Monit.

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

Jaeger is an open-source, distributed tracing platform designed to monitor and troubleshoot microservices-based systems. A critical component of Jaeger is its storage backends, where traces captured by Jaeger are stored. With the release of Jaeger v2 last year we introduced a new, more efficient Storage API v2. However, the existing backend implementations in Jaeger are still using v1 API that is only wrapped in the v2 adapter, which prevents them from benefiting from the new capabilities such as batch writes and result streaming. The objective of this project is to upgrade some (or all) backend implementations to use the Storage API v2 natively. Please refer to the upstream issue for more details. Expected Outcome: 1) Upgrade memory and Elasticsearch backends to use the Storage API v2 natively. 2) Bonus: upgrade Cassandra and Badger backends to use the Storage API v2 natively.

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>The Haskell developer tool ecosystem, while greatly improving in recent years, has a performance problem. Haskell IDE Engine (HIE), the most popular implementation of the language server protocol for Haskell, is a great example of this. While it is an incredibly useful tool, its variable performance interferes with the productivity of Haskell developers.</p> <p>Profiling tools is another area where the Haskell ecosystem is lacking. While some tools do exist (for example ThreadScope), they are not as polished as similar tools for other languages, and do not allow for remote monitoring, which can be incredibly useful in distributed applications.</p> <p>I believe these two problems have a common solution: OpenTelemetry is a set of APIs and protocols made for instrumenting code, gathering traces and metrics, and analysing all that data, in a language-agnostic way, on a variety of independent clients.</p> <p>As my Google Summer of Code Project, I would like to first improve the newly-created haskell-opentelemetry library, use that to instrument HIE, and then optimise it based on my findings.</p>

<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>

Currently Apache SkyWalking can collect logs from various sources like user agents and Envoy access logs, it also provides a log analysis language to analyze the logs and produce some metrics, with those metrics, users can configure rules to trigger alerts and react to those abnormal/exceptional logs. But in reality, production environment exceptional logs are not known in advance and users can't enumerate all possible exceptional logs. This task aims to add an algorithm that can identify outlier log(s) from the massive logs, and draw the users attention to see whether there is error in the system. Log acquisition, log analysis, feature extraction, and anomaly detection are the four aspects of this algorithm. To extract the relevant features in log events, the feature extraction technique divides the log data set into finite blocks using a window. A representative approach of supervised learning is used to execute the final anomaly detection process (SVM). The algorithm should be able to learn from bot the history logs and streaming logs, and adjust itself to increase the accuracy.

The proposal for the GSOC project focuses on the "Optimization of CUDA and OpenCL performance" within the gprMAX software, a tool utilizing the Finite-Difference Time-Domain (FDTD) method for detecting anti-personnel landmines and addressing practical challenges. Problem Being Solved: The primary challenge this proposal aims to address is the optimization of CUDA and OpenCL performance within gprMAX to enhance its computational efficiency. This is critical for the application's ability to perform tasks such as detecting anti-personnel landmines more effectively. Solution Approach: The project will be tackled through a series of analytical and optimization stages, focusing on CPU/GPU computing stage segmentation, system-level analysis using Nsight System, and GPU-level analysis with Nsight Compute. These stages are designed to identify and alleviate bottlenecks in the system, with particular attention to Streaming Multiprocessors (SMs), Video Memory, and the Instruction Set Architecture (ISA). Based on the above analysis, the deliverables should contain several parallel branches. Each component will be thoroughly tested to verify its effectiveness and reliability before integrating these optimizations into the main project branch.

<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>