Explore Projects

The Kolibri Design System contains resources for designers and developers building Kolibri products. With inclusivity at the heart of Learning Equality’s mission, the purpose of KDS is to reduce the time it takes to design & build products while ensuring accessibility, responsiveness, and cross-browser compatibility. Currently, Data tables in Kolibri and Studio are implemented using CoreTable and SortableHeader components. However, this implementation does not support adding sorting functionality to the tables, which is one of the most common tools for data management. Sorting helps arrange data meaningfully to make it easier to understand, compare, and visualize. Also, using these components leaves too much to the developer to ensure accessibility across all user sections. This project aims to develop a new KDS component, a sortable table to provide a solution to these problems.

The llama nexus project is an API proxy to provide OpenAI-compatible and unified API endpoints for multiple downstream API servers, including LLamaEdge API servers running open-source LLMs. https://github.com/LlamaEdge/llama-nexus Currently, the Llama Nexus supports the stateless /chat/completions API endpoint for LLMs. We would like to expand this to support the /responses stateful API from OpenAI as well. https://platform.openai.com/docs/api-reference/responses https://platform.openai.com/docs/guides/responses-vs-chat-completions In particular, we aim to implement support for MCP Code interpreter Web search File search Browser use (optional) Expected Outcome: 1. New features for the Llama Nexus proxy server.

<h4>Motivation</h4> <p>To record actions of users within the CMS, to know who to blame when something wrong happens.</p> <h4>Project Description</h4> <p>This project is about making a Joomla! CMS extension to store the tasks performed by any user, informing those who did, where did when did and what made within the project. This project has two main parts: capturing the log data and viewing the captured data. It will be a package that contains a plugin to store events and a component to view, filter and control them.</p> <h4>Implementation</h4> <p>I'll build a package that contains a component, plugin and module. The plugin will have the logging system that will store users actions based on Joomla events.The component will be for viewing logs and controlling deleting and logging options. The module will be for viewing the logs of current user in the back-end.</p>

<p>This idea will focus on the development of web based GUI for the Grass “WebGrass” where people can use Grass modules through a web browser without actually installing GRASS. GRASS will be running on a server. The user interface will be built using wt web toolkit. Wt provides C++ API for developing web widgets. Wt is a page based framework. This means the web application written in Wt has are close to be alike desktop application. Wt’s Singal slot mechanism inspired from Qt allows to connect events from Wt widget to javascript calls. Also this can be the first step in making a Enterprise wide FOSS4G tool where GRASS is running on the server and user can use it with any client, processing being done on the server. In future, a cloud based application deployment can be done.</p>

<p>The aim of this feature is to make it possible to connect to VM consoles using VNC client called NoVNC in browsers.noVNC is an HTML 5-based remote desktop web client which can communicate with a remote VNC server via WebSockets. Using noVNC, you can control a remote computer in a web browser over VNC. noVNC has a full VNC client implementation in JavaScript/HTML5. However, noVNC is still limited by the fact that JavaScript cannot make plain TCP connections. noVNC uses WebSockets to connect to the server. noVNC includes a generic WebSockets to TCP bridge ( WebSockify ) that you can run on the server or the client. Using noVNC would be better than the current customized VNC in ACS. However, this project aims at adding noVNC support along with the current VNC feature. They will communicate to the VM via different ports.</p>

kgateway routes AI inference traffic to self-hosted model servers. It picks the best server using EPP scoring — based on KV cache usage, queue depth, and LoRA affinity. That scoring costs more than simple round-robin routing, but there's no data on how much latency it actually adds or what a normal regression looks like for this setup. This project adds the benchmarking layer kgateway is missing. I'll build a reproducible test environment using the upstream GIE methodology, run scenarios comparing agentgateway with inference extension against a plain Kubernetes Service, set up a two-tier CI pipeline (mock server for regular runs, real Azure GPU for releases), store results in Azure Blob, and add regression detection that blocks CI when p99 latency crosses a stored threshold. The regression detection piece was what was missing from the issue discussion.

This project aims to create a web-based tool that can make user interfaces from "Thing Descriptions" (TDs) - a term from the Web of Things standards. Unlike other tools out there, ours will handle multiple things at once so users can monitor and control their IoT setups from one screen. The project will develop the WoT UI component library that can be reused and Eclipse Thingweb platform with an entirely device driven dashboard and UI components that can be dynamically adjusted based on device capabilities without any coding/manual selection needed for new devices. Deliverables include: A Handy Web App to Create User Interfaces A Library to Power UI for WoT Real-time interaction using HTTP and WebSocket protocols. A UI-Affordance Mapping documentation guide mapping TD elements to UI components. AI-powered suggestions for TDs with unknown or irregular structures.

<p>This project aims to make OODT deployment and configuration management simple through implementation of a docker-based deployment tool that integrates with the existing distributed configuration management tool in OODT. The target is to first containerize the major components in OODT (file manager, resource manager and workflow manager) using Docker. Each component will then have its own Dockerfile and Maven build execution using the dockerfile-maven plugin. Next, the initial OODT deployment tool will be created using Kubernetes. Once this is done, the existing OODT Distributed Configuration Management feature will be integrated with this tool to handle dynamic configuration management. As a later step, the deployment could be upgraded to work with Helm or KNative.</p> <p>Through this project, OODT will gain the ability to seamlessly manage OODT components regardless of the deployment environment. Technologies including Docker, Kubernetes and Maven will be required to carry out this project.</p>

This proposal aims to bolster the security measures of our application by implementing a Bloom Filter to detect malicious links efficiently. It addresses the challenges of cost and complexity associated with existing solutions by leveraging the rbloom Python library. Additionally, it explores the integration of ChatGPT into server environments such as clickbait and fake news detection, offering potential cost savings and enhanced capabilities. Furthermore, it proposes leveraging ChatGPT for text summarization tasks to improve information retrieval and knowledge consolidation. Cloud integration is a key aspect, with plans to develop a CI/CD pipeline and explore cost-effective cloud solutions like ECS, EKS, Lambda functions, Azure, GCP, and AWS free tiers. Standardizing server code structures, documentation, and implementing a testing/development server aim to streamline the development process. Overall, the proposal aims to enhance security, efficiency, and cost-effectiveness while advancing the application's functionality and user experience.

<ul> <li>Enhancing the <strong>Loklak Search</strong> webapp by fixing bugs and adding new features to the application which are performant and stable.</li> <li>Enhancing the UI/UX experience of the application using the performant animations and <strong>material design</strong> the existing and new components of the application.</li> <li>Writing <strong>unit tests</strong> for more tighter <strong>CI integration</strong>, as well as more robust linting which is best for both developers and code base.</li> <li><strong>Documentation</strong> of the modules and components so that it becomes easier for other developers for understanding the code base and collaborating.</li> <li>Collaborating in writing effective, usable and stable components including the <strong>media wall</strong>.</li> <li>Making the application to <strong>load faster</strong> and making it <strong>performant</strong> and <strong>lighter</strong> and eventually taking the path of a <strong>PWA</strong>.</li> </ul>

<p>This project focus on building about the server side of the Catalog Service for the Web(CSW) is base on OGC Catalogue interface standards use the Apache CXF framework, CXF enables the development of RESTful services via annotations using the HTTP Binding. Using URI templates and annotations that can bind a service operation to arbitrary URL/verb combinations. For each new metadata added to the CSW, relevant metadata will been server read only once and stored in a PostgreSQL database. This database would be used by the CSW engine for performing the search. About the client side, I will creat a client application simple, from there, the user can search for metadata they are interested in CSW. Implementing OGC CSW is not only applicable for VNSC but also for other space agencies in searching images by criteria since the metadata used in this project (provided by VNSC) is largely used by other space agencies. This project aims the web server application would be developed in the Apache SIS application/sis-webapp module.</p>

<p>My work is targeting the Scratch to Catrobat converter. The Scratch to Catrobat converter is a tool that converts programs written in MIT's popular visual desktop programming language Scratch into Catrobat programs. In contrast to Scratch, Catrobat is a visual programming language tailor-made for mobile devices, like smartphones and tablets.</p> <p>This project is intended to improve the user experience of the conversion process. The main points of these improvements refer to replacing the web interface with a native UI (directly integrated into Pocket Code's Android app) and implementing a WebSocket client that communicates with a central web service. In addition to that, users can search for Scratch programs inside the app and select programs they would like to convert. Those Scratch programs are then converted by the server into Pocket Code programs that can be executed on their mobile device. On the server-side, the web service should act as a central hub for any kind of client applications being planned in the future. Thus, server-related preparations and improvements have to be made as well.</p>

<p>End-to-end encryption (E2EE) has been gaining relevance during the last years due to the increasing privacy concerns of users. Encrypting communications between the client and the server using SSL is not enough to protect users privacy, since data can be read in plaintext in the server, which is not trustworthy.</p> <p>It is trickier to perform E2EE into SwellRT documents than it is to perform it into simple chat messages. SwellRT use operational transformations (OTs) to coordinate the insertion and deletion of characters in its documents, so instead of encrypting the entire document, we need to encrypt each operation and still guarantee that the server has enough information to coordinate the document editioning. Fortunately, it is a field that has been researched for many years and we have some studies that have successfully implemented E2EE in Google Docs. We can take their insights to encrypt SwellRT OTs.</p> <p>The project has two parts. First, we need to encrypt and decrypt successfully SwellRT OTs, using a symmetric key. Then, we need to communicate those symmetric keys among users, and here is where we need public key cryptography.</p>

<p>So as to handle huge volumes of data generated due to distributed and scalable nature of PCP, Redis an in-memory NoSQL data cache is being used in PCP for search and serving time series performance data. Since PCP metadata and data keys are distributed across potentially many Redis servers, Redis nodes need to communicate with one another for data access/transfer. Communication between Redis nodes (Redis clients with the Redis servers) is carried out by protocol called RESP (REdis Serialization Protocol). As Redis protocol (RESP) and the pmproxy'd PCP protocol can co-exist, the main goal of this project is extending pmproxy to support RESP such that an arbitrary Redis client can access the distributed key store using the direct key-to-server mapping mechanism used by the existing PCP time series code. Sub-goals include integrating libuv library with pmproxy. libuv is a multi-platform support library with a focus on asynchronous I/O.</p>

Thanos Ruler is a critical component in Thanos that is responsible for the alert evaluation and recording rules. However, a few extensive rules can create a significant amount of resulting time-series, limiting the scalability of Thanos Rule, as it uses a single embedded TSDB. Recording/Alerting Rules are a substantial piece of monitoring infrastructure, so we want to ensure users can operate Rulers and scale them in an easy way. There is no way to scale rule evaluation and storage today except functionally sharding rules onto multiple instances of the Thanos Ruler component. Luckily, we have already solved scaling storage of time-series across various processes using Thanos Receiver. To scale rule evaluations and storage, during this mentorship, you will have a chance to implement the proposal that allows the Thanos rule component to have a stateless mode, storing results of queries by sending them to a Thanos receive hash-ring instead of storing them locally. You will learn about Go, Time-series databases, distributed system design, Prometheus, and of course Thanos.

Apache NuttX, while offering a Unix-like RTOS environment, currently lacks support for the vast ecosystem of X11-based graphical applications. This limits its usability in embedded GUI scenarios. This project addresses the gap by porting NanoX (also known as Microwindows), a compact X11-compatible server, to NuttX. The port will adapt NanoX’s client-server communication from Unix sockets to NuttX’s message-queue model, and rework the Nano-X server backend to run on top of NuttX’s NX/NXTK window system instead of accessing the framebuffer directly. It will also integrate NuttX’s input subsystem for mouse, keyboard, and touch support while preserving Nano-X/NX11 compatibility. The result will be a Nano-X/NX11 compatibility layer on NuttX that can run applications such as FLTK with minimal changes. Time permitting, I'll also port of FLTK 1.3 and the Dillo web browser to demonstrate real-world application capability.

Istio extends Kubernetes to establish a programmable, application-aware network. Working with both Kubernetes and traditional workloads, Istio brings standard, universal traffic management, telemetry, and security to complex deployments Istio does not support HTTPs based metric scraping for control plane, gateway, and Envoy sidecar metrics This could have some security related consequences: - An attacker might find some sensitive information that they can use for their advantage. For example, Envoy /stats endpoint can be used to enumerate all upstream services in the cluster. - In theory an attacker could masquerade the metrics endpoint(s) and inject fake data to monitoring systems, in order to e.g. hide an ongoing attack, confuse the system to autoscale up/down etc. It would be nice to protect the metrics endpoints with TLS, using mutual authentication. While this feature is a big one covering multiple components, the easiest component alone is intended to be covered as part of this internship. Expected Outcome: - Implement HTTPS metrics for ztunnel component - Add unit tests and integration tests for the feature - Add documentation for the functionality

<p>Laying down a strong foundation &amp; base architecture for Intrusion detection &amp; prevention system (IDS/IPS), intelligent log monitoring, antivirus that can be scaled in future and also can be further expanded easily by applying machine learning. Enhance the current firewall by bringing in some advanced rules to detect malformed &amp; suspicious packets &amp; dump them into a PCAP file for future forensic analysis. Implement OSINT tools to collect information about attackers and generate a CSV report. Introduce Auto Server patcher to patch server configuration for maximum security features and implement a server-side web deface detection. Also, protect IoT devices by checking if they are under the Shodan radar. Perform all the elemental connections &amp; introduce different modes for the user. Improve the GUI by adding all the configurations options and critical data such as last login to it. Perform bug fixes and improve the dashboard. Write detailed documentation and README, and finally package and ship SecureTea version 1.1 on PyPi.</p>

<p>This proposal is about implementing HTTP/2 for HTTPServer.jl and Requests.jl, as well as implementing a heuristic for Mux.jl for HTTP/2’s “server push”. In the end, It is expected that Mux.jl, HTTPServer.jl and Request.jl users can seamlessly transit to HTTP/2 with little changes on their sides.</p> <p>Here are some expected outcomes of this project.</p> <ol> <li>A new, unified version of the HTTPServer module and Requests module for both HTTP/1.1 and HTTP/2. The API "disables" certain methods and options for a HTTP/1.1 connection.</li> <li>Extensions such as Alternative Services and Opportunistic TLS will be implemented in HTTPServer.jl and Requests.jl.</li> <li>Specifically for HTTPServer.jl, expose a nice “server push” API that allows other libraries to specify what other resources to push along with the requested resources.</li> <li>In Mux.jl, build a middleware for HTML and CSS to extract resources to be “server pushed”. Good documentation and tests for those middlewares.</li> </ol>

<p><a href="https://github.com/balabit/syslog-ng/" target="_blank">syslog-ng</a> is an famous log management infrastructure for users all over the world. Syslog-ng is rightly known as the "Swiss Army Knife of logging" because of its rich filtering capabilities, flexible configuration options. <a href="https://tools.ietf.org/html/rfc6455" target="_blank">WebSocket protocol</a> is a protocol enabling two-way communication between a client and server over a single TCP connection.<br> This project will add WebSocket as a destination for syslog-ng. The new destination can send log messages to an WebSocket Server directly. In addition, this project will enable the new destination to act as a WebSocket server, so the WebSocket client (such as a javascript client in a browser) could subscribe directly to it to get log messages. These will make sending log message privately or publicly much easier. This project will add WebSocket as a source for sysnlog-ng. So that it can receive log much more conveniently in some area such as IoT world.</p>

<p>CC Vocabulary is a design system, a collection of UI components, available both as CSS stylesheets and minified JS, as well as Vue components, that make it easy to develop Creative Commons apps and services while ensuring a cohesive experience and appearance across CC projects.</p> <p>CC Vocabulary would make it easy for designers to design and prototype mockups, developers to develop evolving standards-compliant code that covers a large number of use-cases out-of-the-box and users to navigate a more consistently familiar CC web presence.</p> <p>CC Search is a Creative Commons application that allows users to search for images (and soon, other content) and provides one-click attribution and licensing information, making it effortless and unambiguous to use and extend creative works from other artists.</p> <p>The revamped CC Search would provide a more streamlined experience, making the site mobile-responsive, modernised and smoother to use. The website would also be the pilot project to use the new CC Vocabulary components, enabling faster development and a more consistent look and feel.</p>

Have you ever encountered a frustrating error when browsing a webpage, or perhaps landed on a page expecting to find information about the first computer, only to discover something completely unrelated? When we request a webpage, the server communicates its status through an HTTP response code. If the page is broken or doesn't exist, the server responds with a 404 error code or some other error code in the 4xx and 5xx range, indicating an issue, and 200 OK (or some other status codes in the 2xx range) if everything is good. However, a common challenge arises when the server returns a 200 OK in every case, making it difficult for computers to differentiate between a healthy page and a problematic one. If these problematic pages go unnoticed and are not replaced with their healthy counterparts over time, they contribute to a pervasive issue known as "link rot," leading to the gradual loss of valuable internet information. This work addresses such issues by performing content analysis of webpages to identify potential soft-404s that would otherwise go undetected due to the wrong HTTP status code they return. A prior version of such soft-404 pages is then looked up in the Wayback Machine to replace the link in the Wikipedia article with, if present.

Git's partial clone allows cloning repositories without downloading all objects (blobs, trees, ...). These objects are fetched on demand from the remote when needed. However, when a user needs metadata about these remote objects (size, type, hash, ...), Git has no efficient way of doing this without downloading all the object content. The server side support for `object-info` protocol was implemented by Calvin Wan in 2021. Eric Ju built the client-side `remote-object-info` for `cat-file --batch-command`. This project finishes Eric Ju's work on `remote-object-info` for `git cat-file --batch-command`, resolves the pending feedback from Junio Hamano and Jeff King, and extends support for `%(objecttype)`. The main technical fix is to replace the insufficient `strstr()` format validation with an `allow_list` to prevent crashes on unsupported placeholders, and extending the v2 protocol server and client to handle `%(objecttype)`. After the project, Git will have a working `remote-object-info` for `cat-file --batch-command` supporting `%(objectsize)`, and a v2 protocol extension adding `%(objecttype)` support on both server and client, with tests and documentation.