Tech Stack: C# 100.0%

Last Commit: 2/19/2026

Commits: 23

View on GitHub

---

AES Implementation in C#

A simple, educational implementation of the Advanced Encryption Standard (AES) algorithm in C#. This project demonstrates the core AES encryption and decryption processes with a focus on clarity and learning.

Educational Purpose Only: This implementation is intended for learning and educational purposes. Do NOT use this in production environments or for securing sensitive data.

Quick Start

Prerequisites

• .NET 9.0 SDK or later

Supported Features

• ✅ AES-128 encryption and decryption
• ✅ Single block operations (16 bytes)
• ✅ Row-based state representation
• ✅ NIST SP 800-38A test vector compliance

Limitations

• ❌ Only supports 128-bit keys
• ❌ Single block only (no chaining modes like ECB, CBC)
• ❌ No initialization vectors (IV)
• ❌ Not optimized for production use

Performance Benchmarks

Latest benchmark results on Ubuntu 24.04.3 LTS with Intel Core i5-12450H:

Method	Mean	Error	StdDev	Ratio
Custom AES Encrypt	4,048.8 ns	74.34 ns	62.07 ns	~4.9x
Custom AES Decrypt	7,394.6 ns	31.49 ns	29.46 ns	~8.7x
.NET AES Encrypt	832.0 ns	3.82 ns	3.58 ns	1.0x
.NET AES Decrypt	847.2 ns	5.56 ns	4.64 ns	1.0x

Testing

The implementation is thoroughly tested against NIST Special Publication 800-38A and FIPS 197 test vectors:

dotnet test --verbosity normal

All tests validate:

• Correct encryption of known plaintext/key pairs
• Proper decryption back to original plaintext
• Compliance with NIST standards

Learning Resources

• NIST SP 800-38A - AES Test Vectors
• FIPS 197 - AES Standard

License

This project is for educational purposes only. Please refer to the license file for details.

Contributing

This is an educational project. Feel free to fork and experiment, but remember this is not intended for production use.

Tech Stack: C# 100.0%

Last Commit: 2/17/2026

Commits: 10

View on GitHub

---

CATBOT Azure HTTP Function with Meta Webhook

This Azure Function project implements a Facebook Messenger bot that automatically sends cute cat photos to users who message your Facebook page. The bot uses Azure HTTP-triggered functions to handle Meta webhooks and respond with adorable cat images.

How It Works

1. Users send messages to your Facebook page via Messenger
2. Facebook sends webhook events to your Azure Function endpoint
3. The function processes the incoming message
4. Bot responds automatically with a cute cat photo utilizing free cat api https://developers.thecatapi.com/

Architecture

• HTTP Trigger Function: The azure function receives POST requests from Facebook's webhook system
• Webhook Verification: Validates incoming requests using Facebook's verification token
• Message Processing: Parses incoming message events and user data
• Cat Photo API Integration: Fetches random cat images from external API
• Messenger Send API: Sends cat photos back to users via Facebook's Graph API

Setup Instructions

Prerequisites

• Azure subscription with Function App deployed
• Facebook Developer Account
• Facebook Page for the bot

Facebook Developer Setup

1. Create Facebook App: Visit Facebook Developers and create a new app
2. Configure Webhooks: Follow the official Facebook Graph API Webhooks Documentation
3. Set Webhook URL: Point to your Azure Function HTTP endpoint
4. Configure Page Access Token: Generate token for your Facebook page
5. Subscribe to Events: Enable messages and messaging_postbacks events

Azure Function Configuration

1. Deploy Function: Deploy this project to your Azure Function App

2. Environment Variables: Configure the following app settings:

   • META_PAT: Page access token from Facebook
   • META_APP_SECRET: Your webhook verification token (the secret)

3. HTTP Endpoint: Note your function's HTTP trigger URL for webhook configuration

Learn More

• Azure Functions HTTP Triggers
• Facebook Messenger Platform
• Meta Webhooks Documentation

Tech Stack: TypeScript 49.9%, C# 42.7%, HCL 4.7%, Dockerfile 1.2%, JavaScript 0.7%, CSS 0.4%, HTML 0.4%

Last Commit: 2/19/2026

Commits: 77

View on GitHub

---

ChoreMaster

A Simple Household Task Management System
Transform your chaotic chore routine into an organized experience!

---

Technologies Used

• Frontend: React 18 + TypeScript
• Styling: Bootstrap
• Backend: .NET 9
• Database: PostgreSQL with Entity Framework ORM
• Authentication: JWT + OAuth2 (Google)
• Deployment: Azure + Terraform
• Testing: xUnit + .NET Testcontainers
• CI/CD Automation: GitHub Actions

---

Core Features

• Create, edit, and delete chores
• Manage users (create/edit/delete)
• Delegate chores to specific users
• Mark tasks as completed and reassign them to a user
• View full task history
• Configure custom task time thresholds
• Display relations and time left for each task

---

Overview of the App

---

Setting It Up Locally

Backend

Prerequisites

• .NET 9 SDK
• Entity Framework CLI tools
• Docker and Docker Compose

Setup Steps

1. Start PostgreSQL database:

   docker-compose up -d
   

2. Create environment file: Create a .env file in the backend directory with your connection string:

   DATABASE_CONNECTION_STRING=your_connection_string_here
   

3. Run Entity Framework migrations:

   dotnet ef database update
   

4. Start the backend:

   dotnet build
   dotnet run
   

---

Frontend

Prerequisites

• Node.js (npm version 10.8.2 or higher)

Setup Steps

1. Install dependencies:

   npm install
   

2. Start the development server:

   npm run dev
   

   The app automatically uses http://localhost:5272/api for the backend in development.

---

Production Deployment

Prerequisites

• Azure CLI installed and configured
• Terraform installed
• Docker Hub account
• Azure subscription

GitHub Secrets Configuration

Before deploying to production, configure the following secrets in your GitHub repository (Settings → Secrets and variables → Actions):

Secret Name	Description
DOCKERHUB_USERNAME	Your Docker Hub username
DOCKERHUB_TOKEN	Your Docker Hub access token
AZURE_CREDENTIALS	Azure service principal credentials (JSON format)
PRODUCTION_API_URL	Your production API URL (e.g., https://api.yourapp.com)

Deployment Steps

1. Login to Azure:

   az login
   

2. Navigate to the infrastructure directory:

   cd infrastructure
   

3. Initialize Terraform:

   terraform init
   

4. Review the deployment plan:

   terraform plan
   

5. Apply the infrastructure:

   terraform apply
   

6. Push to main branch:

   Once the infrastructure is set up, pushing to the main branch will trigger the CI/CD pipeline that:

   • Runs backend tests
   • Builds Docker images for frontend and backend
   • Pushes images to Docker Hub
   • Updates Azure Container Apps with the new images

---

Tech Stack: TypeScript 89.9%, CSS 8.6%, JavaScript 1.4%

Last Commit: 3/9/2026

Commits: 37

View on GitHub

---

Intermezzo Staff

A staff management and time-tracking web app for small businesses — built to track daily work inputs, cash flow, and shift schedules. Built for a small cafe in my home city.

---

Tech Stack

Layer	Technology
Framework	Next.js 16 (App Router) + React 19 + TypeScript
Auth	NextAuth v5 — Google OAuth
Database	MongoDB (Atlas)
UI	React Bootstrap 5 + Custom CSS Modules
Calendar	FullCalendar (day/week/month views)
Utilities	date-fns, react-spinners
Hosting	Vercel-ready (Next.js server actions)

---

Role-Based Access

Access is controlled via environment-level email whitelists:

• Standard users — can view and edit their own data only; edit window limited to current month + last 2 days
• Admin users — elevated privileges: view all employees' data, filter by employee, access full wallet history

Authentication is handled through Google OAuth — only whitelisted emails can log in.

---

Pages

Wallet /wallet

Tracks the business cash balance. Users can submit balance updates with a timestamp. Admins see the full history of all updates (shown in the História accordion); standard users see the current balance only.

---

My Inputs /myinputs

Daily work log table. Each entry records hours worked, start/end times (auto-calculates hours), cash and terminal turnover, day expenses, and start/end float amounts. Filterable by month. Admins can view entries for all staff. Older entries outside the edit window are masked with ****.

---

Timetable /timetable

A color-coded shift calendar showing staff schedules. Powered by FullCalendar with day, week, and month views. Each employee is assigned a distinct color.

---

Tech Stack: TypeScript 91.0%, CSS 4.6%, JavaScript 4.2%, Shell 0.2%

Last Commit: 3/11/2026

Commits: 77

View on GitHub

---

Life Organizer

A personal productivity application built with Next.js 14, featuring task management, work reports, and workout tracking. The app uses Google OAuth for authentication and MongoDB for data persistence.

Tech Stack

• Framework: Next.js 14 (App Router)
• Authentication: NextAuth.js with Google OAuth
• Database: MongoDB
• UI: React Bootstrap
• Language: TypeScript
• Deployment: Vercel free tier + Atlas

Home (/)

• Landing page showing welcome message for authenticated users
• Displays access denied message for unauthenticated users

Tasks (/tasks)

• Daily task management system
• Date-based task organization
• Create, update, and toggle task completion
• Tasks persist per date in MongoDB

Work Reports (/workreports)

• Daily work report editor
• Rich text editor with formatting options
• Date-based report management
• Integrated Pomodoro timer for time management
• Create and update reports for specific dates

Workouts (/workouts)

• Workout tracking and management
• Built-in stopwatch timer
• Rich text editor for workout details
• Add, edit, and delete workout entries
• View workout history

Notes (/notes)

• Note tracking and management
• Rich text editor for note details
• Add, edit, and delete note entries

Tech Stack: C# 100.0%

Last Commit: 2/17/2026

Commits: 8

View on GitHub

---

Mandelbrot Set Visualizer

A desktop application for rendering and exploring the Mandelbrot set, built with C# and Avalonia UI targeting .NET 9.

About

The Mandelbrot set is one of the most famous fractals in mathematics. A point $c$ in the complex plane belongs to the set if the sequence defined by:

$z_{n+1} = z_n^2 + c, \quad z_0 = 0$

remains bounded (does not diverge to infinity). This application renders the set on a 1000×1000 pixel canvas, coloring points that belong to the set in red.

Features

• Real-time rendering of the Mandelbrot set
• Pan navigation using arrow keys to explore different regions
• Zoom in by pressing Space to increase magnification
• Adaptive iteration count — the maximum number of iterations automatically increases as you zoom deeper, improving detail at higher magnifications

Controls

Key	Action
Arrow Up	Pan up
Arrow Down	Pan down
Arrow Left	Pan left
Arrow Right	Pan right
Space	Zoom in

Performance Note

You can scroll (zoom) into the set to explore its infinitely complex boundary, but be aware that performance degrades significantly after a few zoom levels. The rendering is not heavily optimized — each zoom step requires recalculating every pixel on the canvas, and as the iteration count increases with deeper zoom levels, the computation becomes substantially more expensive. This is a known limitation of the current implementation and would require significant optimization (e.g., multithreading, GPU acceleration, or perturbation theory) to handle deep zooms smoothly.

Getting Started

Prerequisites

• .NET 9 SDK

Run

cd MandelBrot/MandelbrotApp
dotnet run

Tech Stack

• C# / .NET 9
• Avalonia UI 11.3 — cross-platform UI framework
• WriteableBitmap — pixel-level rendering

Tech Stack: C# 100.0%

Last Commit: 2/19/2026

Commits: 11

View on GitHub

---

PriceChecker

A .NET tool that monitors product prices on the web and notifies you by email when your target price is hit.

How It Works

1. Define items to track in InputConfig.xml — each entry has a URL, a target price, and a regex to extract the current price.
2. The tool fetches each page, parses the price, and compares it to your goal.
3. Every 30 minutes, it sends an email summary via Mailjet SMTP showing actual vs. target prices and whether each goal was reached.

Configuration

<root>
    <Recipient>you@example.com</Recipient>
    <ItemWebResource>
        <url>https://example.com/product</url>
        <priceGoal>49.99</priceGoal>
        <regexPricePattern>price-regex</regexPricePattern>
    </ItemWebResource>
</root>

Setup

Set your Mailjet SMTP keys as environment variables:

PUBLIC_KEY_PARSERTOOL=<your-public-key>
PRIVATE_KEY_PARSERTOOL=<your-private-key>

Then run:

dotnet run --project PriceChecker

Tech Stack: C# 96.6%, Shell 3.4%

Last Commit: 2/19/2026

Commits: 25

View on GitHub

---

RAG (Retrieval-Augmented Generation) - C# Implementation

A C# implementation of a Retrieval-Augmented Generation (RAG) system that processes PDF documents and enables intelligent question-answering using local AI models.

Overview

This RAG implementation allows you to ask questions about PDF documents by combining semantic search with large language models. The system extracts text from PDFs, converts it into semantic vectors, stores them in a vector database, and retrieves relevant context to generate accurate answers.

Architecture

The system uses the following components:

• Qdrant: Vector database for storing and searching semantic embeddings
• Ollama with Phi3 model: Local LLM for generating embeddings and completions
• PdfPig: PDF text extraction library
• .NET 9.0: Runtime environment

How It Works

1. PDF Processing: Extract text content from PDF documents
2. Text Chunking: Split the text into manageable chunks
3. Overlay Chunking: Create overlapping chunks to maintain context continuity
4. Semantic Vectorization: Convert each chunk into semantic vectors using Ollama's Phi3 model
5. Vector Storage: Store all vectors in Qdrant vector database
6. Query Processing: Convert user queries into semantic vectors
7. Similarity Search: Use Qdrant to find the most relevant chunks via semantic search
8. Context Augmentation: Compose a final prompt with retrieved context
9. Answer Generation: Generate accurate answers using the LLM with relevant context

Prerequisites

• Docker with GPU passthrough support enabled
• NVIDIA GPU (required for Ollama to run efficiently)
• .NET 9.0 SDK or later

Docker GPU Setup

Ensure Docker has access to your GPU. You need:

• NVIDIA Container Toolkit installed
• Docker configured with --gpus=all flag support

Tech Stack: JavaScript 57.7%, C# 40.5%, CSS 0.8%, Dockerfile 0.7%, HTML 0.3%

Last Commit: 2/18/2026

Commits: 162

View on GitHub

---

RSTracker

RSTracker helps coaching staff make data-driven decisions about player load management. By tracking daily RPE (Rating of Perceived Exertion) and wellness scores across a squad, the application calculates key performance indicators such as training load volume, intensity, and the Acute:Chronic Workload Ratio (ACWR) -- a widely recognized metric for assessing injury risk.

The platform is designed around the concept of league weeks (7-day windows), allowing staff to review and compare data on a week-by-week basis aligned with the competitive schedule.

---

Key Features

Player Management

• Maintain a full squad roster with player profiles (name, age, position, weight, height)
• Add and remove players with cascading data cleanup

RPE Tracking

• Record daily session RPE values and training duration per player
• Automatic calculation of session training load (RPE x duration)
• Daily team averages, volume percentages, and intensity metrics
• Comparison against built-in reference norms for each day of the week

Wellness Monitoring

• Track four daily wellness dimensions per player: Muscle Status, Recovery Status, Stress, and Sleep
• Each dimension scored on a 1-7 scale (total wellness score out of 28)
• Mid-week recovery assessment via Wednesday-Thursday-Friday averages

ACWR Analysis

• Acute:Chronic Workload Ratio calculation over configurable time windows
• Multi-week trend visualization to identify periods of elevated injury risk
• Combined volume and intensity breakdown per week

Data Visualization

• Bar charts for daily wellness and RPE summaries
• Combo charts comparing actual RPE loads against daily reference norms
• Stacked bar charts for weekly RPE breakdowns across the ACWR period
• ACWR ratio trend charts spanning multiple weeks

Weekly Data Views

• Day-by-day tables showing individual player values alongside team averages
• Week summary tables with aggregated statistics
• Date picker navigation to browse historical data by league week

---

Screenshots

RPE Bar Chart -- daily training load visualization

RPE Norm Chart -- actual loads compared against daily reference norms

Wellness Chart -- daily wellness score overview

ACWR Analysis -- workload ratio trends across multiple weeks

Player Management -- squad roster administration

Player Data, RPE, Wellness and Management -- combined data entry view

---

Sports Science Background

RPE (Rating of Perceived Exertion)

RPE is a subjective measure of how hard a player perceives a training session to be. When combined with session duration, it produces the session RPE or total training load:

$\text{Session RPE} = \text{RPE Value} \times \text{Duration (minutes)}$

Volume and Intensity

• Volume is expressed as a percentage of the maximum expected daily load (baseline of 760):

$\text{Volume} = \frac{\text{Total RPE}}{760} \times 100$

• Intensity normalizes volume by time to account for differences in session length:

$\text{Intensity} = \frac{\text{Volume}}{\text{Common Time} / 95}$

Wellness Scoring

Players self-report four metrics daily, each on a 1-7 scale:

Metric	Description
Muscle Status	Perceived muscle soreness and readiness
Recovery Status	General sense of physical recovery
Stress	Mental and emotional stress levels
Sleep	Sleep quality and duration

The total wellness score ranges from 4 to 28. The platform also calculates a Wednesday-Thursday-Friday average, commonly used to assess recovery state heading into match day.

ACWR (Acute:Chronic Workload Ratio)

The ACWR compares the current week's training load against the rolling average of the previous four weeks:

$ACWR = \frac{\text{Current Week Load}}{\text{Average of Previous 4 Weeks}}$

ACWR Range	Interpretation
Below 0.8	Undertraining -- potential detraining risk
0.8 - 1.3	Safe zone -- optimal load management
1.3 - 1.5	Caution -- elevated injury risk
Above 1.5	Danger zone -- high injury risk

Daily Reference Norms

The system includes built-in daily RPE norms for a typical training week to compare against actual loads:

Day	Mon	Tue	Wed	Thu	Fri	Sat	Sun
Reference RPE	300	600	580	110	220	760	0

---

Technology Stack

Frontend

Technology	Purpose
React 19	UI framework
Vite	Build tool and dev server
React Router DOM	Client-side routing
React Bootstrap / Bootstrap 5	UI component library and styling
Chart.js + react-chartjs-2	Data visualization and charting
chartjs-plugin-datalabels	Chart label overlays
MSAL React + MSAL Browser	Microsoft Entra ID authentication
date-fns	Date manipulation and formatting
react-datepicker	Date selection component
react-select	Enhanced dropdown selects
react-toastify	Toast notifications
react-spinners	Loading indicators

Backend

Technology	Purpose
.NET 9 / ASP.NET Core	Web API framework
Entity Framework Core 9	ORM and database migrations
PostgreSQL (via Npgsql)	Relational database
JWT Bearer Authentication	API security
Swashbuckle / Swagger	API documentation
Newtonsoft.Json	JSON serialization
Azure Key Vault	Secrets management
Azure Blob Storage	Structured operation logging
In-Memory Cache	Response caching with TTL-based invalidation

Infrastructure

Technology	Purpose
Docker	Containerization with multi-stage builds
Nginx	Frontend reverse proxy and SPA routing
Azure Container Apps	Cloud hosting
Azure Key Vault	Centralized secrets management
Azure Blob Storage	Append-style daily log files

Testing

Technology	Purpose
xUnit	Test framework
Testcontainers	Integration testing with real PostgreSQL instances

---

CI/CD

The project uses GitHub Actions for continuous integration and deployment. A workflow is triggered on every push to the main branch and performs the following steps:

1. Test -- restores .NET dependencies, pulls a PostgreSQL image, and runs the full xUnit test suite (including Testcontainers-based integration tests)
2. Build -- builds Docker images for both the backend (ASP.NET Core API) and frontend (React SPA served by Nginx), tagged with the short commit hash
3. Push -- pushes both images to Docker Hub
4. Deploy -- authenticates with Azure and updates both Azure Container Apps (backend and frontend) to use the newly built images

This ensures that every merge to main is automatically tested, containerized, and deployed to production.

---

Authentication

RSTracker uses Microsoft Entra ID (formerly Azure Active Directory) for authentication.

• Users log in through a browser redirect flow via the Microsoft identity platform
• The frontend acquires an access token using MSAL (Microsoft Authentication Library) with the configured API scope
• Every API request includes the token in the Authorization: Bearer {token} header
• The backend validates the JWT against the configured Azure AD tenant and audience
• All API endpoints are protected -- unauthenticated requests receive a 401 response

---

Testing

The test suite uses xUnit with Testcontainers to spin up real PostgreSQL instances during integration tests, ensuring database operations are tested against actual database behavior rather than mocks.

Test coverage includes:

Test File	Coverage
PlayerHelperTests	Player CRUD operations and data retrieval
RPEManagerTests	RPE calculations, weekly aggregation, volume, and intensity
WelnessManagerTests	Wellness scoring, weekly summaries, and mid-week averages

Azure Blob Storage logging is mocked during tests to isolate database-focused assertions.

---

License

All rights reserved.

Tech Stack: JavaScript 49.4%, Python 36.6%, Shell 6.7%, Dockerfile 4.7%, CSS 1.9%, HTML 0.8%

Last Commit: 2/22/2026

Commits: 71

View on GitHub

---

rugit.fun — Solana Token Creator

Create your own Solana SPL token in under two minutes, directly from your browser.

What it does

Fill in your token details, connect your Phantom wallet, and pay 0.1 SOL. The app handles everything else — uploading your logo to IPFS, minting the token on Solana mainnet, and sending it straight to your wallet.

What you can configure

• Token Symbol & Name — ticker and display name
• Supply & Decimals — total amount to mint and decimal precision
• Description & Logo — metadata attached on-chain (JPEG/PNG/GIF, 512×512 or 1024×1024, max 100 KB)
• Social links — Twitter, Telegram, Website (optional)
• Disable Mint — permanently remove the ability to mint more tokens
• Disable Freeze — permanently remove freeze authority

Requirements

• Phantom wallet browser extension
• 0.1 SOL + a small network fee

How it works under the hood

1. Payment & validation — after you sign the transaction, the backend verifies it on-chain via the Solana RPC. It checks that the transaction is confirmed, less than 5 minutes old, and that the payment went to the correct recipient address. If the RPC is slow, it retries up to 10 times before giving up.

2. IPFS upload — your logo and a metadata JSON file are uploaded to Pinata. The metadata URI is what gets attached to the token on-chain.

3. Token minting — the backend runs the Solana CLI and spl-token CLI to create the token with the Token-2022 program (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb), initialize on-chain metadata, mint the supply, and transfer it to your wallet. Each CLI command is retried up to 5 times on failure.

4. Cleanup — temporary files are deleted after minting. IPFS pins and logs older than 1 hour are automatically purged by a background cleanup job.

Tech stack

Layer	Tech
Frontend	React 19, Vite, React-Bootstrap
Wallet	@solana/wallet-adapter (Phantom only)
Blockchain	Solana mainnet via QuickNode RPC
Backend	FastAPI (Python), Uvicorn
IPFS	Pinata
Minting	Solana CLI + spl-token CLI (Token-2022)
Logging	Azure Files
Hosting	Azure Container Apps (backend)

Live

rugit.fun