[Data Tools]
[Developer Tools]
- AuthCraft ( https://authcraft.pages.dev )
- Glyph ( https://glyphgallery.pages.dev )
- Stringfy ( https://stringfy.pages.dev )
[Finance]
[Security]
- Cryptoledger ( https://cryptoledger.pages.dev )
- Cryptosign ( https://cryptosign.pages.dev )
- Peercipher ( https://peercipher.link )
Arrow & Parquet is a high-performance, fully client-side data transformation and analysis tool designed to bridge familiar data formats with modern, high-speed querying engines directly in the browser. It allows users to import Arrow, Arrows, CSV, and JSON files, instantly converting them into the highly optimized Parquet format using Rust WebAssembly. Native Parquet files can also be imported directly.
Once the data is securely loaded, an embedded DuckDB WASM engine enables users to perform complex SQL queries, validate data structures, and aggregate large datasets with zero server latency. The app is integrated with the Monaco editor, which allows users to take advantage of features like Modern SQL IntelliSense. After filtering and shaping the data, the final output can be exported as Arrow, Arrows, CSV or Parquet files for seamless integration into downstream machine learning workflows or BI tools.
To handle robust data operations and large WebAssembly payloads without hitting strict hosting limits, the application is deployed via GitLab Pages and utilizes the browser's Origin Private File System (OPFS). This guarantees high-speed local storage and ensures that all data processing remains strictly local, providing absolute data privacy without ever transmitting sensitive information to an external server.
Built with Astro, Rust WebAssembly, and DuckDB WASM.
AuthCraft is a code first generator for authentication buttons that gives you full control over design and output. It allows you to create polished sign-in buttons for providers like Google, GitHub, and Apple with precise customization. You can export assets as SVG, PNG, or WebP or directly integrate clean, production ready code into your project. It removes the need to manually recreate provider buttons and ensures consistency across your interface.
Built with Blazor WebAssembly.
https://cryptoledger.pages.dev
Cryptoledger is a fully client side, offline first distributed ledger application designed for secure and portable record keeping. It uses modern WebAuthn passkeys so private keys are never exposed to the browser, while cryptographic operations are handled by the operating system and authenticator.
A single JSON file acts as the database, making it easy to transfer, back up, and audit across devices and controlled environments. Each block is re hashed and signature verified locally using Rust WebAssembly, ensuring append only integrity and authenticity without requiring any server or network connection.
The system combines a static frontend with a Rust powered verification layer, allowing the entire ledger to be validated in a self contained environment.
Built with Astro and Rust WebAssembly.
Cryptosign is a client side web application for creating and verifying detached cryptographic signatures without relying on servers or external services. It allows authors to sign files locally using passkeys, while recipients can verify file integrity offline using the original file, signature, and public key.
The app is organized around three main workflows: Key Manager, Signer, and Verifier. In the Key Manager, a user creates a passkey signing identity and extracts the matching public key for sharing with clients. The Signer workflow is designed for detached signatures rather than embedded or wrapped documents. The Verifier checks whether the signature matches the file contents and the declared signing algorithm.
Built with Astro and Rust WebAssembly.
https://glyphgallery.pages.dev
Glyph is a modern icon exploration tool built for developers and designers. It provides access to a large collection of over 30,000 scalable vector icons across multiple libraries. The interface offers fast search, real time preview, and easy customization of size and color. Icons can be downloaded instantly as SVG files, making integration into projects seamless and efficient.
Built with Vite.
Peercipher is a privacy-focused peer-to-peer file transfer app for moving sensitive files through temporary rooms. The backend is used only for short-lived signaling, while files, chat messages, encrypted WebRTC transport, OPFS buffering, and transfer recovery are handled in the browser.
Files are chunked and encrypted with AES-GCM before being sent through WebRTC data channels. WebRTC also provides encrypted transport by design. When a direct peer-to-peer route is unavailable, Coturn can relay encrypted WebRTC packets through the VPS, but it does not receive plaintext files or store relayed streams as replayable file content.
The app is deployed with an Astro frontend on Cloudflare and a FastAPI signaling backend plus Coturn TURN server on a VPS.
Built with Astro, FastAPI, WebRTC, OPFS, Cloudflare Tunnel, Coturn, and Docker images.
Quantix is a financial analysis platform that integrates valuation and performance frameworks into a single workflow. It enables you to evaluate fair value, business quality, and market expectations using models such as DCF, dividend based valuation, and implied multiples. DCF and DDM are calculated using my own algorithm.
The app uses an SQLite database, but users need to generate one themselves using financial stock data in QuantConnect.
The platform brings together profitability, capital structure, return metrics, growth trends, cash conversion, and volatility into a unified view. You can analyze leverage, liquidity, shareholder returns, and capital allocation decisions without leaving the core workflow.
Quantix also provides sensitivity analysis tools that help you test assumptions and explore upside, downside, and risk scenarios. Focused chart clusters make it easy to examine price ranges, margins, growth, solvency, and market behavior in a clear and structured way.
Built with Docker images, FastAPI, Vite, and Cloudflare Tunnel.
SleekDB is a high-performance, client-side data transformation tool designed to convert multiple CSV files into a unified SQLite database instantly. It features a streamlined workflow for uploading existing databases and performantly updating them by inserting or replacing records from local CSV files, making it an essential utility for analysts and developers managing large-scale structural data.
The application utilizes a decoupled, worker-based architecture that offloads the database engine to a dedicated background thread. By leveraging the Origin Private File System (OPFS) and synchronous SQLite WebAssembly, SleekDB achieves near-native I/O speeds and handles massive datasets with zero UI latency. Every operation is processed entirely within the browser, ensuring enterprise-grade privacy and robustness—no data ever leaves the local environment.
SleekDB includes an OPFS Storage Manager that gives users direct visibility into the browser’s local database workspace. It allows them to inspect temporary SQLite files stored in OPFS, download or delete scratch databases, and control automatic cleanup behavior on worker boot through a simple UI preference. This makes the storage layer more transparent and easier to manage while preserving the app’s fully local, privacy-first architecture.
- Cross-Origin Isolation [Active]: Unlocks high-speed OPFS support via SharedArrayBuffer.
- Worker Architecture [Enabled]: Prevents UI freezing during intensive data operations.
- OPFS Storage [Enabled]: Near-native I/O for large-scale database files.
- Privacy First [Local]: 100% client-side execution; no data ever leaves the device.
Built with Vite and SQLite WebAssembly.
Stringfy is a secure text obfuscation tool designed to protect sensitive information from bots and automated scrapers. It transforms phone numbers, email addresses, and other contact details into Base64-encoded images, ensuring they remain readable to humans while being inaccessible to machines. The app generates lightweight SVG, PNG, and WebP assets and works entirely without client-side JavaScript, making it fast, reliable, and privacy friendly.
Built with Astro and Rust WebAssembly.
US Yield is a treasury yield and estimated total return visualization app for exploring key US Treasury maturities, including 3M, 1Y, 2Y, 5Y, 10Y, and 30Y. It uses FRED constant maturity treasury yield data and generates daily, weekly, and monthly chart series for current yield, implied total return, and rolling CAGR metrics.
The total return indices shown in this app are not official Treasury or market indices. They are estimated constant maturity treasury total return series derived from yield changes and coupon accrual assumptions. The app also calculates rolling 5Y, 10Y, and 30Y CAGR values, plus cumulative CAGR, from those estimated total return indices.
The data pipeline runs through GitHub Actions, which refreshes FRED yield data, generates static JSON chart files, and deploys the app to Cloudflare Pages. Because the chart data is precomputed and served as static JSON, the app does not call the FRED API each time a user opens a chart. This avoids unnecessary API traffic, reduces the risk of excessive requests, and keeps chart loading fast for users.
Built with Astro and Rust.