Explore Projects

<p>Implementation of various tags in profile page which improves community interaction in PublicLab.org organization and also improving the response time of profile page.</p> <p>Profile tags are a creative tool that lets PublicLab.org users add tags to their profile which highlights the things that describe them. Main focus of this project is to add various profile tags such as location data, role, tools, skills to user profiles which improves user base community side interaction. Improving the current Barnstar implementation by providing a new layout in profile page. In the current system, comments are displayed with image icon and description which will be refactored based on the role user possess such as admin, moderator, organizer. On the other hand as huge amount of data is rendered in the front end of the application, response time is another important factor project will focus on. I will be using agile software development method which includes iterative and incremental approach</p> <p>My work can be found here: <a href="https://github.com/publiclab/plots2/commits/master?author=lalithr95" target="_blank">https://github.com/publiclab/plots2/commits/master?author=lalithr95</a></p>

<p>Transaction-Level Verilog (TL-Verilog) is an emerging language extension to System Verilog, Has the ability to define flexible reusable components. For this project, will develop a library of compatible components such as FIFOs, queues, arbiters, elastic buffers, etc. that could form the basis of a new era of hardware design,And will demonstrate the ease of composing these components into sophisticated transaction flows and quickly implementing what are currently considered to be complex designs, such as a complete on-chip network!</p>

Description: WasmEdge would like to integrate WasmEdge as an alternative runtime for Fluvio. We would like to create a compile-time feature for the [fluvio-smartengine](https://github.com/infinyon/fluvio/tree/master/crates/fluvio-smartengine) crate. Once this feature is turned on, the compiler will choose to embed WasmEdge into the binary build using the [WasmEdge Rust SDK](https://wasmedge.org/book/en/sdk/rust.html). Expected Outcome: A complete PR and a demo app that uses WasmEdge to process streaming data using a Tensorflow or Pytorch model

This project aims to improve CircuitVerse by adding new components that are useful for learning about real hardware, such as shift registers (SISO, SIMO, MISO, MIMO), comparators, and a buzzer (speaker), Priority MUX, etc. It will also introduce support for connecting CircuitVerse with real devices using the Browser’s Web Serial API, allowing users to interact with physical hardware directly through the simulator. These features will help people better understand how digital circuits work—both in theory and in practice. The goal is to make CircuitVerse more powerful and helpful for learning digital circuits and embedded systems.

Bhyve is a modern type 2 hypervisor originally written for FreeBSD. The goal of this project is to enhance the functionality of its debugging server. Several existing features related to single-stepping are tied to Intel-specific VM mechanisms, which severely impairs bhyve's debugging functionality on other platforms. Thus, the first major goal of this project is to rework the single-stepping mechanism to use the RFLAGS.TF VMEXIT mechanism. This will allow bhyve to support debugging guest operating systems on AMD platforms, which would facilitate kernel development for more 64-bit x86 hardware (other than Intel). The second goal is adding support for hardware watchpoints (and optionally hardware breakpoints) using the guest OS's hardware debugging registers. This will improve the kernel development workflow and allow easier and faster fixes for various kernel memory corruption bugs.

While the Open Medical Record System (OpenMRS)'s major objective is to store and retrieve electronic medical records in the developing world, in some areas this objective has been frustrated due to lack of a stable internet connection, tech-illetracy and rampant power outages in most parts of the developing world. A patient's medical history and treatment may be well documented but due to lack of internet, computers and electricity in the next facility, that patient may not be in position to receive the service due to lack of reference document hence breaking continuity of care among health care providers, its is against this background that the print feature was development. so that at any point in time, a patient and the service provider can have a hard copy of whichever document they want. how I plan to solve it; 1. have a list of areas where printing is required and add them to the configurations 2. Add the print button in the selected areas 3. write code for the print function using the react-to-print package 4. write tests

The proposal aims to enhance Eclipse Winery, a web-based environment for modeling OASIS TOSCA topologies, by implementing basic security measures. Currently, Winery focuses on providing a graphical editing environment for modeling application topologies. However, the proposal suggests adding a Language Server Protocol (LSP) provider for OASIS TOSCA YAML files. This would allow Winery to support the latest version of the OASIS TOSCA standard and handle dynamic type additions. The expected outcomes of the project include: 1-Developing an LSP server that supports the latest OASIS TOSCA 2.0 standard. 2-Ensuring that the LSP server is aware of newly introduced types and makes them available in the service template. 3-Enabling the LSP server to handle multiple files. 4-Demonstrating the functionality of the LSP server using compatible IDEs such as Eclipse Theia, Visual Studio Code, or Eclipse IDE. 5-Writing clean and maintainable code, with a preference for using modern Java (version 21 or later). The proposal indicates that the project's size is estimated at 350 hours and rates its difficulty as medium. Overall, the proposal aims to improve the security and functionality of Eclipse Winery by implementing an LSP server for OASIS TOSCA YAML files, thereby providing a more robust and comprehensive modeling environment.

The JSON Schema website currently uses custom UI components, which increases maintenance complexity and slows down updates. This project modernizes the site by integrating a UI library like ShadCN/UI and refactoring components into a modular, consistent system to improve maintainability and user experience. Work includes theming the UI library, updating layout and navigation with dark mode support, and improving Markdown rendering by refactoring StyledMarkdown.tsx into a more flexible and maintainable system. This will support advanced features like tables, tab groups, and a dynamic table of contents, while replacing legacy overrides with modern equivalents. All changes will be supported by clear documentation and implementation guide for future contributors. The project will also resolve all related open issues, including long-standing bugs and enhancement suggestions tied to the adapted components.

<p>Apache SkyWalking already has a Python Agent with relatively complete functions, but it still has some functional deficiencies compared with Java Agent. One of these is the ability to profile running projects.  In this project, I will implement the profiling function for the Python Agent of SkyWalking. Because the Java Agent already implements this functionality, so the code in the oapserver and the report protocol can be reused, but the Python Agent needs to implement the code that accepts the profiling task command and the code associated with the profiling sample.</p>

PyZombis is a dynamic community course designed to teach Python to Spanish-speaking individuals, inspired by the Brazilian MOOC, Python para Zumbis. Delivered entirely online, PyZombis eliminates the need for users to install Python on their local machines or manage server configurations. However, the current implementation relies on Brython for executing Python within a browser environment, leading to inherent limitations. Certain functionalities, non-native Python modules, and C-built Python modules pose challenges for interactive learning experiences. The proposed solution aims to enhance PyZombis's interactivity and usability by addressing these limitations. The primary focus will be on PyZombis and the RunestoneComponents repositories. Key objectives include: Introducing a PyScript component to facilitate advanced exercises, enhancing interactivity and skill development, Implementing a Tkinter wrapper to enable browser-based execution of exercises, removing dependency on local installations, Enhancing user engagement through the implementation of a new user interface, fostering an immersive learning environmen, Strengthening the educative platform by integrating end-to-end playwright tests, ensuring reliability, and addressing pending issues for continuous improvement, Implementing stretch goals and overhauling documentation to further enrich the learning experience and accessibility. By addressing these objectives, the proposal aims to elevate PyZombis into a comprehensive and interactive learning platform for Python enthusiasts within the Spanish-speaking community.

The current validator of component model inside of WasmEdge only check nested module and ensure VM can run the nested modules without problem, but the validations from component model are mostly skipped. Expected Outcome: 1. One should create a workable (merged into upstream) implementation of validator by working on 2. include/validator/validator_component.h 3. lib/validator/validator_component.cpp 4. The visitor pattern are already setup. Recommended Skills: Since component model proposal separate their validation spec, one should able to find requirements from https://github.com/WebAssembly/component-model/tree/main/design/mvp

Jaeger (https://www.jaegertracing.io/) is an open-source, distributed tracing platform designed to monitor and troubleshoot microservices-based systems. Jaeger-UI is the web UI for Jaeger, built with React (https://react.dev/) . The current version of React used by Jaeger-UI is v18. This project aims to upgrade Jaeger-UI to React v19, in order to stay up to date with the dependencies. Expected Outcome: A working version of Jaeger-UI upgraded to React v19, with all the features and functionality of the current version. This may include a need to upgrade or replace some other dependencies that may not be compatible with the latest React.

<p>Connected components algorithms are used to analyze graph and solve problems (like 2-satisfiability problem). There are three parts of connected components algorithms in the Boost Graph Library (BGL),</p> <ol> <li>Connected components algorithm.</li> <li>Strongly connected components algorithm.</li> <li>Biconnected components algorithm. </li> </ol> <p>I am proposing to add those BGL functionalities to pgRouting during this GSoC period.</p>

The project focuses on enabling real-time multilingual accessibility for Eventyay’s live streaming platform by introducing interpreter audio alongside existing YouTube video streams. It includes the development of a browser-based interpreter console that captures audio via WebRTC using a Jitsi-based infrastructure, allowing interpreters to stream translated speech with low latency. On the viewer side, a multi-language audio player will allow users to subscribe to preferred language tracks while maintaining synchronization with the video through automatic and user-adjustable timing offsets. On the backend, interpretation settings such as languages, streams, and synchronization offsets will be integrated into the existing Eventyay admin system and associated with sessions. A lightweight audio pipeline will process interpreter input into scalable HLS streams for reliable delivery. Work also includes ensuring seamless integration with the current platform, maintaining synchronization accuracy, and supporting multiple concurrent language streams. The outcome will be a scalable and user-friendly multilingual streaming experience, enabling organizers to configure interpreter settings, interpreters to operate from a unified browser interface, and viewers to seamlessly select their preferred language during live sessions.

This project aims to test the performance of |toqito⟩ and compare it with other quantum computing libraries. It is divided into three parts: (1) Comparing |toqito⟩ with libraries like PennyLane, Qiskit, etc. by running standardized tests inside Docker to ensure consistency across different computers; (2) Automatic benchmarking using GitHub Actions, where performance tests run on every update and results are stored for analysis; and (3) Identifying slow parts of |toqito⟩ using cProfile, focusing on operations like matrix calculations, quantum measurements, and random object generation. ------------------------------------------------------------------------------ Deliverables include: 1. A new benchmark/ folder in |toqito⟩ that can run and store benchmarks, including support for running them in Docker. 2. A system to track |toqito⟩’s performance over time using monthly benchmarks or we can choose to run only relevant benchmarks after each merged PR. 3. Found and suggested improvements for slow parts in at least one full module of |toqito⟩.

A language server is what makes it possible to rich editing like to go to definition or code completions in source code editors. The Solang Solidity Compiler does have a language server, but it is very rudimentary. The aim of this mentorship is to make the language server much more complete, will make developing Solidity code using this language server will be a much greater developer experience. During this mentorship you will learn how language servers work, and you'll need to walk the parsed Solidity abstract syntax tree in various ways to for example find where a variable is defined (Go to definition), or to find all usages of a variable (Find all references), or find the type definition (Go to type definition). This means walking a complex data structure, and understanding how source code is represented as a abstract syntax tree, which is the result of parsing and semantic analysis, the first stage of an compiler.

Implement fuzz testing for KubeArmor using a suitable tool like oss-fuzz or AFL. Generate a comprehensive input set to guide the fuzz testing, profile execution using tools like pprof to detect anomalies, and identify components such as the policy controller, operator, configmap handler, and GRPC endpoints for testing. Document the entire process for repeatability in future versions and develop an automation strategy for ongoing fuzz testing. Expected Outcome: Improved OSSF Score; Standards for Fuzz Testing for KubeArmor; Stabilization of KubeArmor

<p>Task would be to get the data from Elasticsearch as a stream and model it as a graph in order to provide insights on the fly. Once we map the data stream into a graph model, we can use the high performing graph algorithms to cluster the data and send through different nodes for further processing.</p>

This project enhanced Gradle Build Server for Android development by implementing composite build support, improving Java Home handling, and providing support for Android Java projects. These enhancements significantly improve the development experience for Android developers using Text Editors/IDEs that utilize the Build Server Protocol (BSP). By bridging the gap between Android Studio and Gradle Build Server, this project contributes to a more productive development workflow. This is a start to let developers benefit from the powerful capabilities of Android Studio within their preferred development environments.

Jaeger UI is built on React. While we are seemingly already on v18.x of React, the upgrade was not done across the board and some other dependencies are still lagging behind, e.g. `"@types/react": "16.8.7"`. It's also blocking upgrades of other dependencies. This project is likely to involve a substantial amount of code contribution, as certain upgrade require fixing the code to use the new APIs, and sometimes we may run into dependencies that are EOL and need to be replaced altogether. - Expected Outcome: Ideal outcome is to have _all_ dependencies upgraded to the latest versions (with the help of @dependabot) and fix all deprecation warnings during the build. But incremental progress towards that goal is also acceptable.

Devfiles are YAML files that define development environment running in the cloud. The main part of a Devfile is the components section and specify the containers required to code, build and test an application. Some components, such as those to code and build the application, need to be deployed as soon as development environment is provisioned. Others instead are supposed to be started later, usually when a command is triggered by the developer to test the applicaiton she is working on (a database for example). The current definition of the latter type of coponents is complicated and not self explanatory. The goal of this project is to add a new component field to specify if the component should be included at startup or not.

Description: [TestGrid](http://testgrid.k8s.io) is the test visualization tool attached to Prow to collate and display historical test results for the k8s and k8s-adjacent Expected Outcome: Create Lit-based view components for TestGrid (summary, index, etc.) that display data from the API. Implement Jasmine and Storybook testing for these components.

Now KubeVela's VelaUX uses two kinds of Database to store metadata: Kubernetes ConfigMap and MongoDB. As more users are expecting using different kinds of database. We proposing to expanding multiple database drivers for the VelaUX API server. - Expected Outcome: The outcome of this project will be expand two more database driver for KubeVela VelaUX API server: