Projects

tet

Tet is a terminal-based snippet and command manager built in Rust with the help of Ratatui. The project was created to solve a very simple but annoying problem: remembering long command-line commands that are rarely used but still important during daily development work.Instead of repeatedly searching through notes, shell history, or documentation, Tet allows commands to be stored and executed using short and memorable aliases. This makes repetitive workflows much faster and reduces the mental overhead of remembering long commands, server IP addresses, SSH options, or deployment scripts.For example, instead of typing a long SSH command manually every time:ssh [email protected] -p xxxxWe can simply run:tet ssh-server1Commands can also be grouped by project or category, making organisation easier for larger workflows:tet project-1 sshThe CLI also provides a simple way to browse and inspect available commands using:tet listThe project focuses on convenience, speed, and developer ergonomics while also serving as an exploration into building terminal user interfaces in Rust using Ratatui. It combines a lightweight CLI workflow with a structured command management system that makes everyday terminal usage much more efficient. 

Craft Product Review

Product Review is a plugin built to extend the functionality of Craft Commerce by allowing customers to leave reviews for products they have purchased after completing their orders.The main goal of the project was to add a more structured and trustworthy review system to e-commerce websites. Instead of allowing unrestricted reviews from anyone, the plugin focuses on verified purchases, ensuring that reviews are submitted only by customers who actually bought the product.The plugin integrates directly into the order workflow and provides functionality for:Product-based customer reviewsPurchase verification through completed ordersRating and feedback submission

Docx to JATS

This project was created to simplify the process of generating XML files in JATS format for academic journals and publishing workflows. Preparing JATS XML manually can be complicated and time-consuming, especially for users who are not familiar with XML structures or publishing standards.The idea was to make the workflow much more accessible by allowing users to start from something familiar: a DOCX document.Users can upload a DOCX file, and the system automatically extracts the document content and maps it into a structured editing interface. From there, users are directed to an easy-to-use form page where they can review the extracted metadata, validate content, and make adjustments before generating the final XML output.The workflow focuses on reducing manual XML editing while still giving users enough control to verify and correct important publication data before export. The generated output follows the JATS format commonly used in journal publishing and academic archiving systems.The project also explores document parsing, structured data transformation, XML generation, and building user-friendly workflows for technical publishing processes.

Skim

skim is a command-line tool that converts SQL dump files into formats your tools actually understand.There are times when I want to analyse SQL data and need it in JSON or some other format. Previously, I would import the dump into a local database, then write a script to export it. It worked, but it was a lot of steps for something that should be simple. So I thought: why not build a tool that generates the file directly from the SQL dump, skipping the database entirely?skim reads the dump file as a stream and converts every INSERT row into the format you actually need: JSON, JSONL, CSV, YAML, TOML, or Parquet. Rather than loading the entire file into memory, which can be a problem for large dumps. It reads in chunks, so memory usage stays low and consistent regardless of file size.

YSSV - Your Stupid SQL Viewer

A native desktop application for browsing and querying MySQL and PostgreSQL databases. Built with Rust and egui for a fast, responsive, and lightweight experience.FeaturesConnection ManagementSupport for MySQL and PostgreSQLSave, duplicate, and delete connectionsColour labels and grouped connections with drag-and-drop reorderingSSH tunnelling Test connections with real round-trip latency measurementsData ExplorerCollapsible navigation tree:DatabasesSchemasTablesRow countsTabbed interface with context menu actions:Close tabClose other tabsClose tabs to the leftClose tabs to the rightData viewer with:PaginationRow selectionCopy-to-clipboard supportTable structure viewer with:Column definitionsPrimary key indicatorsForeign key indicatorsNullable field annotationsInline data editing with change review before committingSQL editor with syntax highlightingExecute queries using Ctrl + EnterUser InterfaceDark and light themesAdjustable density settings:CompactRegularComfyStructured application logs with automatic daily rotationBuilt with Rust, egui, SQLx, and Tokio. 

Zeclip

Developed with Rust and Tauri, Zeclip is a clipboard analysis tool for Windows that enumerates low-level clipboard formats and presents them in a readable, structured interface. The application includes XML pretty-printing, binary hex dump, and support for FileMaker clipboard structures, making it useful for debugging and reverse engineering clipboard content workflows. Tech:TauriRustHTML

Fortyone

Back in the good old days, I used to play the 41 rummy card game with my friends all the time. It was always full of laughter, chaos, and fun moments that made the game memorable. Nowadays, those moments mostly live in memory, and that nostalgia inspired me to recreate the experience as an online multiplayer game.Of course, playing online can never fully replace sitting together with friends in real life, throwing cards around, and doing silly things during the game. Still, I wanted to capture at least a small part of that experience through this project.This project was quite challenging for me, especially because I was still relatively new to Rust when I started building it. Besides implementing the game rules and multiplayer logic, one of the hardest parts was dealing with concurrency, implementing WebSockets, and shared game state management. Rust forced me to think carefully about ownership, lifetimes, and thread safety in ways that were very different from languages like Python.Even though it is “just” a simple card game, building it taught me a lot about real-time systems, asynchronous programming, and multiplayer architecture. We only used Redis to store the game data.In the end, this project became more than just a game for me. It was both a technical learning journey and a nostalgic attempt to bring back a small piece of those old memories. Tech Stack:RustYewAxumRedisDocker

Yei

Yei is a reusable component library built for the Yew framework. The project was heavily inspired by shadcn/ui and its philosophy of giving developers ownership over their components instead of hiding everything behind a packaged dependency. The name “Yei” itself comes from “Yew UI” — honestly, just a fun little name I came up with.The project uses Tailwind CSS as its styling foundation and focuses on creating modern, reusable UI components for Rust frontend applications built with Yew.I started this project because every time I created a new Yew application, I found myself rebuilding the same UI components over and over again — buttons, accordions, input forms, and other common interface elements. Beyond just the UI itself, handling callbacks, props, state management, and rendering logic in Yew could become repetitive very quickly.Instead of rewriting the same boilerplate for every project, I decided to create a small reusable component system that I could use across multiple applications.The concept is very similar to shadcn/ui:Developers own the generated component codeComponents can be copied directly from GitHub or generated using a CLIGenerated files are fully customizableNo heavy abstraction layer hiding implementation detailsThis approach makes the library flexible and developer-friendly, especially for Rust developers who prefer explicit control over their codebase rather than relying entirely on opaque third-party packages.The project also became a way for me to explore component architecture in Yew, improve ergonomics for Rust frontend development, and experiment with building a more enjoyable developer experience around the Yew ecosystem. 

Websocket Playground

WebSocket Playground is a lightweight web application built for testing and debugging WebSocket servers in a more convenient way. The project was created to simplify the process of inspecting real-time WebSocket communication without needing to rely on browser developer tools.The application supports both raw text messages and structured JSON data, making it flexible for different types of WebSocket APIs and event-driven systems. One of the main focuses of the project was creating a clean and easy-to-use interface for monitoring live communication between the client and server.To make debugging easier, the app includes:Real-time event loggingStructured message inspectionSeparate tabs for connection events and detailed dataSupport for both raw and JSON-based communicationThis project was also an exploration into real-time frontend architecture, WebSocket communication handling, and building developer tooling focused on usability and debugging experience.  

Form Builder

Many websites require forms for contact pages, registrations, inquiries, and other user interactions, but updating or creating new forms often depends on developers. This project was built to make form management more accessible for non-technical users by providing a flexible drag-and-drop form builder directly inside the CMS.The system allows users to visually create forms, arrange fields, configure layouts and alignments, and manage notification settings without writing code. Administrators can configure recipient emails for internal notifications as well as automatic response emails sent back to users after a successful submission.Beyond the visual builder experience, the project also focused heavily on security and reliability. Since forms are one of the most common targets for spam and abuse, the implementation includes input sanitization, validation handling, rate limiting, and CAPTCHA integration to help protect the application from malicious submissions.The overall goal of the project was to create a form management system that is simple for content editors to use while still remaining secure, flexible, and maintainable from a development perspective.

Design-to-FileMaker Automation Workflow

Translating a Figma design into a FileMaker layout is surprisingly time-consuming. Every object needs to be recreated manually, aligned carefully, and adjusted with pixel-level precision. For complex layouts, this quickly becomes repetitive work and significantly slows down development.This project started from a simple question: what if the layout generation process could happen automatically?The biggest challenge was that FileMaker does not provide a public API for injecting layouts externally. However, during experimentation, we discovered that FileMaker allows objects to be copied and pasted between layouts through the system clipboard. That became the entry point.By understanding the clipboard contents, we found that FileMaker stores layout object data as structured XML. Once the XML structure and patterns became clear, it opened the possibility of generating layouts programmatically instead of building them manually.The workflow connects Claude Code with Figma through MCP, allowing design metadata such as coordinates, component variants, dimensions, and styling information to be extracted directly from the design file. That information is then transformed into FileMaker-compatible XML through a custom generation tool. Finally, a clipboard injection script places the generated XML into the clipboard using the exact format FileMaker expects, allowing the layout objects to be pasted directly into FileMaker.The result is a workflow where UI layouts can move from Figma into FileMaker with minimal manual work — removing repetitive placement tasks, reducing human error, and dramatically speeding up layout implementation.

Image Generator

Creating social preview images manually for every page or article can quickly become repetitive, especially when maintaining consistent branding and layouts across a website. This project was built to automate that process by generating images dynamically from reusable templates.The primary use case was generating Open Graph images based on page content, allowing each page to automatically produce a customized preview image for social media sharing. Instead of designing every image manually, the system can render titles, descriptions, branding elements, and other dynamic content directly into predefined templates.The plugin uses Browsershot to render HTML-based templates in a real browser environment and capture them as images through screenshots. This approach makes it possible to design templates using familiar web technologies such as HTML and CSS while still producing high-quality generated images.Although the original goal focused on Open Graph generation, the system was designed to be flexible enough for other use cases as well, including promotional banners, dynamic thumbnails, announcements, and content-driven image generation workflows.