Explore Projects

Inkscape currently lacks an intuitive, user-friendly way to perform spell checking within text elements on the canvas. This project aims to integrate real-time, on-canvas spell checking into Inkscape, enabling users to easily identify and correct spelling errors directly in their artwork. The solution will use the existing spell checking infrastructure and implement interactive UI components, such as wavy underlines and context menus for correction suggestions. Key deliverables include the rendering of spelling error indicators on canvas, user interaction features for correcting errors, performance optimizations, and comprehensive testing. This enhancement will significantly improve the usability and professionalism of text-based design workflows in Inkscape.

The 4diac IDE is an extensible, IEC 61499 compliant engineering environment for distributed control applications. The current state of its graphical editors presents challenges, as they timely result in poor user experience and frequent errors. To overcome these issues, there is a strong need to introduce an automated test suite specifically for the graphical editors. These test suites will detect errors that will enhance the overall reliability of the editors. Through automated testing, we can effectively implement error indicators within graphical models, ensuring timely identification and resolution of issues. With that, these test suites will provide support to features characterized by deep hierarchical nesting, which directly complicates interaction within the graphical editors. By systematically addressing these challenges, we aim to significantly improve the usability and reliability of the graphical editors within the 4diac IDE.

<p>Apache ShardingSphere uses ANTLR (ANother Tool for Language Recognition) as a generator for the SQL parser engine and obtains SQL statements from AST (Abstract Syntax Tree). Currently, the ShardingSphere parser engine has basic Oracle DML SQL definitions but does not align with Oracle documentation.</p> <p>This proposal suggests proofreading Oracle DML SQL definitions and corrects them according to Oracle documentation. This will be achieved by:</p> <ul> <li>Proofread and change the target ANTLR files which contain Oracle DML SQL definitions. </li> <li>Add unit tests to ensure newly proofread and modified SQL definitions work properly.</li> </ul> <p>Once the ShardingSphere parser engine is aligned with Oracle's DML documentation, the users and developers of Apache ShardingSphere can parse a complete set of Oracle DML SQL statements.</p>

<p>The inspiration for this proposal is from elements of Minecraft along with some pre-existing suggestions and ideas within Terasology. The concept of Scenarios has been suggested in the past and would be very important in order to properly develop any notion of “static” worlds such as what would exist for Light &amp; Shadow. In addition, it would provide assistance to creation of exploration worlds such as the suggested Maze world.</p> <p>The implementation of scenarios can be thought of as basically creating a “game maker” style engine built into Terasology.</p> <p>As additional smaller, but very important goals attached to this idea, I intend to extend the currently existing tools for creation which mostly include BlockPicker and StructureTemplates both of these tools work well at what they do, but both are still limited for large creations as they require placing everything by hand. This is where the brush tool I propose can come in handy. The brush tool is designed to allow for “brush-strokes” being made using blocks to quickly create large structures and terraforming. These brush tools would allow for the following interactions.</p>

The DBpedia Databus Python Client currently supports downloading, deploying, and deleting datasets but lacks reproducibility, workflow orchestration, and format interoperability. This project extends the client with three tightly integrated features: First, a Format and Mapping Conversion Layer (Layers 2 and 3 of the Java client pipeline) that enables on-the-fly conversion between RDF triples, RDF quads, and CSV/TSV formats using rdflib — bringing the Python client to feature parity with the Java Databus Client for the first time. Second, a structured Run Manifest System that records every operation as a fixed-format JSON-LD file using the DataID vocabulary. Manifests support replay, summary, and structured error capture — making any Databus operation fully reproducible from a single file. Third, a declarative Workflow Engine that executes multi-step pipelines defined as YAML files, with dynamic step chaining, per-step error recovery (fail, continue, retry), and automatic manifest generation for every run. Deliverables include a working --convert-format flag with 14 round-trip tests, --manifest flag on all three existing commands with manifest replay and summary commands, a databusclient workflow run command with step chaining and error recovery, five tested real-world example workflows, and full documentation — all fully backward compatible.

Summary: The goal of this project is to improve the Linux-Intelligent OCR Solution (LIOS), an open-source tool for text extraction from images, scanned documents, and PDFs using Tesseract and Cuneiform OCR engines. The primary focus will be on enhancing usability, accessibility, and performance, particularly for visually impaired users, while also addressing several existing issues. Problem: LIOS is a powerful tool, but there are several issues that hinder its usability and accessibility. These include problems with the UI/UX design, scanner compatibility, OCR integration, and the lack of proper error handling, which often leads to crashes. Additionally, there are several other bugs that need attention, such as issues with text focus, icon display, and preview functionality. Solution: The project will focus on addressing these issues and improving the overall user experience: UI/UX Improvements: Simplify the interface and improve accessibility, particularly for low-vision users. Bug Fixes & Code Refinements: Address the following specific issues: Text Focus: Ensure the textview regains focus after using Goto Line and Goto Page. Tab Focus: Improve tab focus handling for better navigation. Icon Display: Fix the larger icon issue in the icon view for consistent UI presentation. Print Preview: Fix the Print Preview functionality, which currently isn’t working as expected. Error Handling: Implement proper error handling to prevent crashes and unexpected behavior. Image Rotation: Resolve the automatic deletion issue when rotating selected areas of the image. Find/Replace Accessibility: Ensure the Find and Find & Replace features are fully accessible and functional. Scanner Compatibility: Improve compatibility with various scanner models, ensuring better cross-platform support. Tesseract Integration: Enhance the detection of Tesseract data paths for more accurate OCR functionality.

<p>Hyperledger Cello is an enterprise-grade Blockchain-as-a-Service (BaaS) platform that provides a comprehensive REST API for managing the full lifecycle of Hyperledger Fabric networks (Network, Node, Channel, Chaincode). However, all current operations require users to interact manually through the Dashboard, which presents a steep learning curve for newcomers.</p><p><br></p><p>This project aims to implement an AI-powered operation agent with chatbot interface for Hyperledger Cello. It consists of two components:</p><p><br></p><ol><li>AI Agent Backend: A Python service that wraps Cello's existing REST APIs into LLM. It accepts natural language requests, invokes Cello operations, and returns structured responses. It also provides AI-assisted fault log summarization for common Fabric failures.</li><li>Chatbot UI&nbsp;— A chatbot interface integrated into Cello's existing Dashboard (React), allowing users to interact with the AI agent.</li></ol><p><br></p><p>The combined system enables a natural language-driven operational workflow:</p><p><br></p><p>User (chat message) → Chatbot UI → AI Agent → Cello REST API → Fabric Infrastructure</p><h3><br></h3><h3>Learning Objectives</h3><ul><li>Open Source Collaboration: Familiarity with Hyperledger Cello workflow, code review standards, and CI pipeline.</li><li>Full-Stack Engineering: Experience building a production-integrated feature spanning a Python backend and a React frontend.</li><li>Applied AI Engineering: Proficiency in LLM Tool Calling integration, streaming response handling, and prompt engineering.</li><li>Blockchain Infrastructure: Hands-on understanding of Hyperledger Fabric network topology, node types, and Chaincode lifecycle.</li></ul><h3><br></h3><h3>Expected Outcome and Deliverables</h3><ul><li>Deliverable: AI Agent Backend</li><li>Acceptance Criteria: Python service exposing a chat API endpoint; supports natural language execution of core Cello operations (list/create networks, manage nodes, query channels and chaincodes)</li></ul><p><br></p><ul><li>Deliverable: Chatbot UI (Dashboard)</li><li>Acceptance Criteria: Chat panel integrated into Cello's existing React Dashboard; supports streaming responses; maintains multi-turn conversation context</li></ul><p><br></p><ul><li>Deliverable: Documentation</li><li>Acceptance Criteria: Setup guide for the AI agent</li></ul>

<p>Peace Corps Safety App (PCSA) helps the volunteers to get information about the Peace Corps’ safety and security procedures in a button click. It also has the functionality in reporting and sending messages when the PCV’s (Peace Corps Volunteers) are in trouble. The purpose of my proposal is to suggest the iOS version for the Peace Corps Safety App. The scope covers the initial development of the iOS version to reflect the already developed Android app and the remaining development which is suggested by the UI and general content update by the Peace Corps.</p>

<p>Floating point number operation are not guaranteed to hold correct results. A certain range of errors can occur silently (overflow, underflow, imprecision, etc). This library aims to provide a replacement for floating-point number that warns on error.</p> <p>The library is already in a relatively advanced state. The goal of this project is to bring it in a review-ready state. In this application, I suggest exploring a new design that hopefully should end up being more performant than the current one. I also want to implement the missing features and to complete tests and documentation.</p>

This project aims to make EvalAI better for users. It will improve how errors are handled, add more tests to make sure things work properly, provide clearer documentation to help people understand, and make the user interface more user-friendly with new features like a "My Work" tab. The main goals are to create tests for important components like APIs and workers, develop guides for things like API usage and AWS setup, make error messages more clear, and add new features to enhance the overall user experience.

Kubewarden is a universal policy engine for Kubernetes enabling policy-as-code. It allows users to define and enforce policies for their Kubernetes clusters using any programming language that generates WebAssembly binaries. Recently, Bytecode Alliance introduced Javy, a JavaScript to WebAssembly compiler. This makes it possible to write Kubewarden policies in JavaScript. This project aims to create an idiomatic JavaScript SDK that allows users to write Kubewarden policies in JavaScript. This requires several features including Policy Authoring API. Host Capabilities APIs, Host Capabilities Bridge, Compilation Pipeline, Testing and Validation, Documentation and Tutorials

This project addresses the latency and response time variability issues in the hugegraph-server query engine by introducing memory management framework to it. Currently, the engine utilizes off-heap memory in most OLTP algorithms, but lacks the ability to control memory allocation per individual query, leading to potential out-of-memory (OOM) errors. The project aims to design and implement a unified memory management framework to address this limitation. This framework will include features such as lifecycle management of memory objects, memory capacity restrictions, and an allocator interface for efficient memory allocation and release. By implementing this framework, the project is expected to improve the stability and performance of the hugegraph-server, ultimately enhancing its usability and reliability for users.

HPX currently requires verbose macros like HPX_PLAIN_ACTION and HPX_REGISTER_ACTION to define remote operations across localities. This boilerplate is error-prone and creates a steep learning curve for new users. With C++26 static reflection (P2996), function signatures can be introspected automatically at compile time, eliminating this boilerplate entirely. This project implements reflection-based action definition for HPX, replacing HPX_DEFINE_PLAIN_ACTION with a clean template API that uses scope_builder and fixed_string for compile-time name extraction — building directly on the serialization reflection foundation from PRs #7010 and #7016 already merged into master. A working prototype has been built and tested in the GCC trunk Docker environment prior to the coding period.

I’m building a tool to make working with Kro YAML files easier and more efficient. This tool, called a Language Server Protocol (LSP), will help developers by giving real-time feedback, catching errors early, and suggesting code completions. It will also make code more readable with better syntax highlighting and helpful pop-ups. The LSP will support popular code editors, starting with VS Code. I’ll also include clear instructions and examples to help users get started. My goal is to make writing and managing Kro YAML files faster and less error-prone, so developers can focus on their work without getting stuck on small issues.

This project improves Netlink support in FreeBSD tracing tools by enabling structured decoding of Netlink message payloads. Currently, truss(1) shows raw hexadecimal output for Netlink calls, making it difficult to interpret structured Netlink messages used by subsystems such as pf . The project will implement decoding within libsysdecode by parsing Generic Netlink headers (genlmsghdr), safely iterating over Type-Length-Value (nlattr) attributes, and dispatching to family-specific decoders. Deliverables include Generic Netlink support, a bounds-safe TLV parsing engine, a modular dispatch framework, and at least one functional decoder (pf), enabling human-readable output and providing a scalable foundation for future Netlink decoding.

<p>Zulip is a powerful open source group chat application. It is easy to get started, I used it to contact mentors, discuss in the community etc. I have also deployed a local server in my hostel wing. It resulted in complete success to do various discussions. The best part is you never miss a message even if a server has thousands of users; unread counts are managed, get email and desktop notifications. It’s like impossible to miss a single message even after long vacations. It is an awesome tool for startups and companies to chat and discuss ideas.</p> <p>The project idea aims to enhance current React-Native app, increase user experience, fix bugs, polish app, and add new features.</p>

This project aims to extend the existing cBioAbstractor prototype into a schema-driven formatting pipeline that assists curators in transforming heterogeneous supplemental datasets into cBioPortal-compatible formats. Currently, curation is a manual and time-consuming process due to inconsistent file structures, lack of automated schema mapping, and the need to interpret validation errors manually. This results in inefficiencies, variability, and high onboarding effort. My preliminary extension implementation suggests the feasibility of this approach by connecting existing components, introducing fuzzy column normalization, and providing a simple interface for file upload, transformation, and result inspection. Initial qualitative experiments show that the system can reconstruct correct cBioPortal formats from intentionally perturbed datasets, suggesting strong potential for reducing manual work and improving consistency.

Makerchip Flows aims at developing EDA flows for TL-Verilog leveraging Edalize backend, for open source tools/flows like yosys, Openlane, F4PGA, Silicon Compiler, and also commercial ASIC Synthesis and Simulation tools. The project involves developing Flows with TL-Verilog (Makerchip IDE or SandPiper-SaaS) and integrating them into the website or use as a standalone flow. This involves developing support for tools and creating flows in Edalize. This effort Makerchip Flows also extends to adding TL-Verilog frontend for Silicon Compiler. This wide range of support and ecosystem developments will make TL-Verilog and its ecosystem the go-to for Design, Simulations, FPGA visualizations, and other explorations just within the browser, creating a low cost and low barrier to entry for beginners and engineers.

<p>ODK-X Suitcase is a cross-platform tool that allows the user to upload, download, and update data on an ODK-X Cloud Endpoint from a personal computer . Users can either use the Graphical user interface or the command line interface to perform operations . Users can upload their data in CSV format and access them later. So , Sync endpoint server has to be configured to use the suitcase application. For this project I will focus on five tasks. 1.Presenting user a list of existing table id's and allowing multiple table download at once. 2.Save user credentials and keep user logged in. 3.Improve error handling and display error message to the user for failed requests. 4.Writing unit tests and GUI tests. 5.Improve the documentation.</p>

Chromium is built using LLVM’s LLD linker for all platforms. This project aims to make various improvements to the LLD linker, which will ultimately improve user experience and allow Chromium developers to be more productive. I plan to focus on two key areas: performance, and quality of diagnostics. While LLD is regarded as a faster alternative to system linkers, the new mold linker has shown that there are still speed gains to be had. My work will include bringing parallelism to the construction of various linker-synthesized sections in the Mach-O port, and to input file reading. Regarding diagnostics, I’m going to implement deduplication for “undefined symbol” errors in the Mach-O port and utilize debug information to show where duplicate symbols are defined. If time permits, I’m interested in implementing smaller missing features such as ARM64 linker optimization hints.

Gnuastro is mainly written in the C, so are Python and Numpy. Utilising this fact, pyGnuastro uses Python wrappers to access the base C library while providing a converter between the Gnuastro and Numpy core data structure using Cpython. The project will extend pyGnuastro with additional module, a core data structure and develop a new error mechanism, to ensure accurate reporting in the Python interface. The new method will store the errors in a stack of linkedlist and share it with the caller rather then exiting the program which closes the Python shell. Additionally, this project will extend Gnuastro to leverage GPU compute by incorporating CUDA modules for the corresponding C modules to offload the computationally intensive duties that GPUs can greatly assist with. NVCC and GCC will compile CUDA and C modules, respectively, with GCC performing the final linking and building of shared libraries(Gnuastro).

I plan to make BRL-CAD python bindings. Basically my goal is to make a Python interface for BRL-CAD using MOOSE as the core modeling backend, with a thin C bridge between Python and C++ for stability and portability. The architecture is: Python interface -> moose_rt3 adapter (ctypes) -> C bridge -> MOOSE C++ API -> BRL-CAD database engine -> .g file. I plan to work around 3 goals: 1. Database lifecycle behavior should be consistent across read-only, writable and in memory modes with clear errors when operations are invalid 2. Core primitives and CSG operations should be exported correctly and transforms must be stored as combination-member matrices so results are verifiable by MGED. 3. Unified read access: provide one Python read entrypoint for supported object families with a stable return format and desterministic errors for missing or unsupported objects

Building upon the work done in GSoC 2021 to make programming the PRU easier for beginners, this project aims to add tests, features, and more compatibility for simpPRU, the simple Python-like language that compiles to PRU C and runs natively on the PRU. I will be adding assignment,bitwise operators which increase the efficiency of usage and write testcases for it, adding the compiler flags for generated C code and document their outcomes,the python test would be added to github actions for testsuite,I will be adding support for return statements,calling C from simpPRU,enhance error handling in parser,adding additional testcases for the features present. I will be writing a research paper on simpPRU quoting its need,implementation done and its preferable usage.This will make the overall language more robust and efficient, which will help beginners who are learning to use the PRU or experienced users prototyping something on the PRU.