DEV Community: Akshay

KAlertDialog: A Beautiful Material Alert Dialog Library for Android

Akshay — Wed, 20 May 2026 06:31:37 +0000

KAlertDialog: A Beautiful Material Alert Dialog Library for Android

Dialogs are one of the most common UI components in Android apps.

We use them for confirmations, errors, success messages, loading states, input forms, warnings, and many other user interactions.

But the default Android AlertDialog can feel very basic when you are building a modern production app.

That is why I built KAlertDialog — a beautiful, customizable, Material-style alert dialog library for Android.

GitHub Repository:
https://github.com/TutorialsAndroid/KAlertDialog

What is KAlertDialog?

KAlertDialog is an Android library that helps developers create beautiful alert dialogs with very little code.

It supports multiple dialog types such as:

Success dialogs
Error dialogs
Warning dialogs
Normal message dialogs
Progress/loading dialogs
Input field dialogs
Custom image dialogs
URL image dialogs

It is designed for Android developers who want clean, modern, and customizable dialogs without writing custom layouts again and again.

Why I Built It

While building Android apps, I noticed that dialogs are used everywhere.

For example:

Showing a success message after saving data
Showing an error when something fails
Asking confirmation before deleting something
Displaying a progress loader while an API request is running
Taking user input in a small popup
Showing custom images inside dialogs

Instead of creating custom XML layouts for each case, I wanted a reusable library that makes this easy.

That idea became KAlertDialog.

Installation

Add Maven Central and JitPack in your project repositories:

repositories {
    mavenCentral()
    maven { url 'https://jitpack.io' }
}

Then add the dependency in your app-level build.gradle:

dependencies {
    implementation 'io.github.tutorialsandroid:kalertdialog:20.5.11'
    implementation 'com.github.TutorialsAndroid:progressx:v6.0.19'
}

Basic Usage

Creating a simple dialog is very easy.

new KAlertDialog(this)
        .setTitleText("Here's a message!")
        .show();

With content text:

new KAlertDialog(this)
        .setTitleText("Here's a message!")
        .setContentText("It's pretty, isn't it?")
        .show();

That is all you need to show a clean alert dialog.

Success Dialog

Use a success dialog when an operation completes successfully.

new KAlertDialog(this, KAlertDialog.SUCCESS_TYPE)
        .setTitleText("Good job!")
        .setContentText("You clicked the button!")
        .show();

This can be used after:

Form submission
Payment success
Profile update
File upload
Data save operation

Error Dialog

Use an error dialog when something goes wrong.

new KAlertDialog(this, KAlertDialog.ERROR_TYPE)
        .setTitleText("Oops...")
        .setContentText("Something went wrong!")
        .show();

This is useful for:

API failures
Validation errors
Login errors
Network issues
Payment failures

Warning Dialog

Warning dialogs are useful before performing destructive or sensitive actions.

new KAlertDialog(this, KAlertDialog.WARNING_TYPE)
        .setTitleText("Are you sure?")
        .setContentText("Won't be able to recover this file!")
        .setConfirmClickListener("Yes, delete it!", null)
        .show();

You can also attach a click listener:

new KAlertDialog(this, KAlertDialog.WARNING_TYPE)
        .setTitleText("Are you sure?")
        .setContentText("Won't be able to recover this file!")
        .setConfirmClickListener("Yes, delete it!", sDialog -> {
            sDialog.dismissWithAnimation();
        })
        .showCancelButton(true)
        .setCancelClickListener("Cancel", sDialog -> {
            sDialog.cancel();
        })
        .show();

Progress Dialog

KAlertDialog also supports progress dialogs.

KAlertDialog pDialog = new KAlertDialog(this, KAlertDialog.PROGRESS_TYPE);
pDialog.getProgressHelper().setBarColor(Color.parseColor("#A5DC86"));
pDialog.setTitleText("Loading");
pDialog.setCancelable(false);
pDialog.show();

This is useful when your app is:

Loading data
Calling an API
Uploading a file
Processing a request
Waiting for Firebase/database operations

You can also customize the progress helper dynamically.

Input Field Dialog

KAlertDialog supports input dialogs too.

KAlertDialog dialog = new KAlertDialog(this, KAlertDialog.INPUT_TYPE);
dialog.setInputFieldHint("Write message");
dialog.setInputFieldText("Hello World!");
dialog.setTitleText("Edit Text");
dialog.setConfirmClickListener("OK", kAlertDialog -> {
    kAlertDialog.dismissWithAnimation();

    String inputText = kAlertDialog.getInputText();
    Toast.makeText(this, inputText, Toast.LENGTH_SHORT).show();
});
dialog.show();

dialog.getWindow().clearFlags(
        WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE |
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM
);

The latest version supports setting default text inside the input field using:

dialog.setInputFieldText("Hello World!");

This is helpful when users need to edit an existing value.

Custom Image Dialog

You can show a custom drawable image inside a dialog.

new KAlertDialog(this, KAlertDialog.CUSTOM_IMAGE_TYPE)
        .setTitleText("Sweet!")
        .setContentText("Here's a custom image.")
        .setCustomImage(R.drawable.custom_img)
        .show();

This is useful for:

Brand illustrations
Achievement popups
Custom app messages
Empty states
Promotional dialogs

URL Image Dialog

You can also show an image from a URL.

new KAlertDialog(this, KAlertDialog.URL_IMAGE_TYPE)
        .setTitleText("KAlertDialog")
        .setContentText("Here's a custom image.")
        .setURLImage("put your image url", KAlertDialog.IMAGE_BIG)
        .setConfirmClickListener("OK", null)
        .show();

Supported display types include:

KAlertDialog.IMAGE_BIG
KAlertDialog.IMAGE_CIRCLE

Dark Mode Support

KAlertDialog supports auto dark mode.

You can also tint vector drawables when the app is running in night mode.

new KAlertDialog(this, KAlertDialog.CUSTOM_IMAGE_TYPE)
        .setTitleText("Sweet!")
        .setContentText("Here's a custom image.")
        .setCustomImage(R.drawable.vector_drawable)
        .setDrawableTintOnNightMode(true, R.color.red)
        .show();

This helps the dialog look good in both light and dark themes.

Custom Button Drawable

The latest update also adds support for custom drawable backgrounds for confirm and cancel buttons.

new KAlertDialog(this, KAlertDialog.NORMAL_TYPE, true)
        .setTitleText("Lorem Ipsum")
        .setContentText("Lorem Ipsum is simply dummy text of the printing and typesetting industry.")
        .setConfirmClickListener("OK", null)
        .setCancelClickListener("Cancel", null)
        .confirmButtonDrawable(R.drawable.red_button_background)
        .cancelButtonDrawable(R.drawable.button_background)
        .show();

This makes it easier to match dialog buttons with your app branding.

Change Font

You can apply custom fonts to the title.

new KAlertDialog(this, KAlertDialog.NORMAL_TYPE)
        .setTitleText("Lorem Ipsum")
        .setTitleFontAssets("fonts/os.ttf")
        .setContentText("Lorem Ipsum is simply dummy text of the printing and typesetting industry.")
        .setConfirmClickListener("OK", null)
        .show();

You can also change the content font:

new KAlertDialog(this, KAlertDialog.NORMAL_TYPE)
        .setTitleText("Lorem Ipsum")
        .setContentText("Lorem Ipsum is simply dummy text of the printing and typesetting industry.")
        .setContentFont(R.font.sf)
        .setConfirmClickListener("OK", null)
        .show();

Change Text Colors

You can customize title and content colors.

.setTitleColor(R.color.yourColorName)
.setContentColor(R.color.yourColorName)

You can also customize button colors:

.confirmButtonColor(R.color.colorPrimary)
.cancelButtonColor(R.color.colorAccent)

And button text colors:

.setConfirmClickListener("OK", R.color.black, clickListener)
.setCancelClickListener("CANCEL", R.color.black, clickListener)

Change Content Alignment

KAlertDialog allows you to control content text alignment.

.setContentTextAlignment(View.TEXT_ALIGNMENT_VIEW_START, Gravity.START)

For center alignment:

.setContentTextAlignment(View.TEXT_ALIGNMENT_CENTER, Gravity.CENTER)

This is helpful when your app needs different text layouts for different dialog types.

Hide Confirm or Cancel Button

You can hide confirm or cancel buttons when needed.

new KAlertDialog(this, KAlertDialog.CUSTOM_IMAGE_TYPE)
        .setTitleText("Sweet!")
        .setContentText("Here's a custom image.")
        .setCustomImage(R.drawable.custom_img)
        .showConfirmButton(false)
        .showCancelButton(false)
        .show();

Change Alert Type Dynamically

You can change the dialog type after a user action.

new KAlertDialog(this, KAlertDialog.WARNING_TYPE)
        .setTitleText("Are you sure?")
        .setContentText("Won't be able to recover this file!")
        .showCancelButton(true)
        .setCancelClickListener("No, cancel", sDialog ->
                sDialog.setTitleText(null)
                        .setContentText("Your imaginary file is safe :)")
                        .showCancelButton(false)
                        .setConfirmClickListener("OK", null)
                        .changeAlertType(KAlertDialog.ERROR_TYPE))
        .setConfirmClickListener("Yes, delete it!", sDialog ->
                sDialog.setTitleText("Deleted!")
                        .showCancelButton(false)
                        .setContentText(null)
                        .setConfirmClickListener("OK", null)
                        .changeAlertType(KAlertDialog.SUCCESS_TYPE))
        .show();

This is useful for confirmation flows where you want the dialog to update after the user clicks a button.

Main Features

KAlertDialog includes:

Material-style alert dialogs
AndroidX support
Auto dark mode
Success dialog
Error dialog
Warning dialog
Progress dialog
Input field dialog
Custom image dialog
URL image dialog
Custom fonts
Custom title and content colors
Custom button colors
Custom button drawables
Custom button text colors
Vector drawable tinting in night mode
Title and content alignment
Dynamic alert type change
Confirm and cancel listeners

When Should You Use It?

You can use KAlertDialog when your Android app needs:

Better looking alert dialogs
Reusable dialog components
Fast implementation
Customizable buttons
Dark mode support
Input popup support
Progress/loading dialogs
Clean Java API

It is useful for both small apps and production-level Android projects.

GitHub Repository

You can find the complete source code and documentation here:

https://github.com/TutorialsAndroid/KAlertDialog

If you find it useful, please consider giving it a star on GitHub.
It helps the project reach more Android developers.

Final Thoughts

KAlertDialog was created to make Android dialogs more beautiful, simple, and customizable.

Instead of spending time creating custom dialog layouts for every use case, developers can use KAlertDialog to quickly add polished dialogs to their apps.

If you are building Android apps in Java and want a modern alert dialog library, give KAlertDialog a try.

implementation 'io.github.tutorialsandroid:kalertdialog:20.5.11'
implementation 'com.github.TutorialsAndroid:progressx:v6.0.19'

Happy coding 🚀

I Built Windows11Alert — A Windows Utility That Sends Telegram Alerts When My PC Turns On

Akshay — Mon, 18 May 2026 07:43:55 +0000

Sometimes the best projects are not huge.

Sometimes they are small utilities that solve one specific problem really well.

I wanted a simple way to know when my Windows PC turns on, restarts, or was previously shut down. I did not want a heavy monitoring dashboard or an enterprise-level monitoring tool. I just wanted a clean Telegram notification with useful details.

So I built Windows11Alert.

It is a lightweight Windows utility that sends Telegram alerts when a PC starts. It also detects the previous shutdown or restart event from Windows Event Logs and reports it on the next startup.

Download Now

GitHub repository:

https://github.com/TutorialsAndroid/Windows11Alert

Latest release:

https://github.com/TutorialsAndroid/Windows11Alert/releases/latest

What Windows11Alert does

Windows11Alert runs automatically when Windows starts and sends a Telegram message with system details.

It can report:

PC name
Windows username
Local IP address
Public IP address
Date and time
Boot time
OS version
Processor
Architecture
RAM details
Previous shutdown/restart event

The basic flow looks like this:

Windows starts
        ↓
Windows11Alert runs automatically
        ↓
It checks Windows Event Logs
        ↓
It sends previous shutdown/restart details
        ↓
It sends current startup details

Example Telegram message

The Telegram message looks something like this:

🟢 PC Turned On

🖥️ PC Name: DEV2
👤 User: HP-User1

🌐 Local IP: 192.168.0.5
🌍 Public IP: xxx.xxx.xxx.xxx

📅 Date & Time: 2026-05-16 15:30:12
⏱️ Boot Time: 2026-05-16 15:29:40

💻 OS: Windows 11
🔢 OS Version: 10.0.xxxxx
⚙️ Processor: Intel64 Family...
🏗️ Architecture: AMD64
🧠 RAM: 15.78 GB Total

When a previous shutdown or restart is detected, the app sends another message with details from the Windows Event Log.

Why I built it

The original idea was simple:

Send me a Telegram message whenever my PC turns on.

That part was easy.

Then I wanted to add a shutdown alert.

At first, I tried sending a Telegram message during shutdown itself. I tested multiple approaches:

Task Scheduler shutdown trigger
Group Policy shutdown script
Hidden window shutdown detection
WM_QUERYENDSESSION
WM_ENDSESSION

Some methods worked when tested manually, but failed during actual shutdown.

Why?

Because Windows may close network services very quickly during shutdown. That means the app might detect shutdown but still fail to send the Telegram message before the network closes.

So I changed the approach.

Instead of trying to send the shutdown alert during shutdown, the app reads Windows Event Logs on the next startup and reports the previous shutdown/restart event.

This made the system much more reliable.

Tech stack

This project uses:

Python
Telegram Bot API
Windows Registry
Windows Event Logs
PyInstaller
Inno Setup
python-dotenv
psutil
requests

Python handles the core logic.

Telegram Bot API sends the messages.

PyInstaller converts the Python script into a standalone Windows executable.

Inno Setup creates the installer.

Telegram bot setup

Telegram is a great option for quick alert systems.

To use Windows11Alert, the user needs:

TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here
TELEGRAM_CHAT_ID=your_telegram_chat_id_here

You can create a Telegram bot using BotFather.

Steps:

Open Telegram.
Search for BotFather.
Send:

/newbot

Create your bot.
Copy the bot token.
Send a message to your bot.
Open:

https://api.telegram.org/botYOUR_BOT_TOKEN/getUpdates

Find your chat.id.

Keeping credentials safer with `.env`

One important thing I wanted to avoid was hardcoding the bot token in the Python file.

Hardcoding secrets is dangerous because if the project is pushed to GitHub, the token can leak.

So Windows11Alert uses a .env file:

TELEGRAM_BOT_TOKEN=your_bot_token
TELEGRAM_CHAT_ID=your_chat_id

And the .env file is ignored in Git:

.env
build/
dist/
Output/
__pycache__/
*.spec

This keeps credentials out of the repository.

Of course, .env is not perfect security. If something is stored on a local machine, the local user or admin can read it. But it is much better than hardcoding secrets into source code.

Auto-start using Windows Registry

To make the app run automatically when Windows starts, I used this registry path:

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run

The Python script adds itself to startup using the winreg module.

This means the app starts automatically whenever the current Windows user logs in.

Reading shutdown events from Windows Event Logs

The app checks Windows System Event Logs for shutdown and restart events.

Some useful event IDs are:

1074 - Planned shutdown/restart initiated by user or process
6006 - Event Log service stopped, usually clean shutdown
6008 - Unexpected shutdown

Instead of depending on live shutdown-time Telegram sending, Windows11Alert checks these events after the PC starts again.

That makes the shutdown/restart detection more reliable.

Packaging the app with PyInstaller

After the Python script was ready, I converted it into an EXE.

pyinstaller --onefile --noconsole --icon=icons/alert.ico --name Windows11Alert Windows11Alert.py

This creates:

dist/Windows11Alert.exe

I also created a separate uninstaller utility:

pyinstaller --onefile --noconsole --icon=icons/uninstaller.ico --name uninstaller uninstaller.py

Creating a Windows installer with Inno Setup

After building the EXE, I used Inno Setup to create a proper Windows installer.

The installer:

Copies Windows11Alert.exe to Program Files
Asks for Telegram Bot Token and Chat ID
Creates the .env file locally
Adds the app to Windows startup
Creates shortcuts
Handles uninstall cleanup

This made the project feel like an actual Windows application instead of just a Python script.

Project structure

The final project structure looks like this:

TELEGRAMPCALERT/
│
├── icons/
│   ├── alert.ico
│   └── uninstaller.ico
│
├── Windows11Alert.py
├── uninstaller.py
├── Windows11Alert_Setup.iss
├── README.md
├── .gitignore
│
├── build/
├── dist/
└── Output/

Generated folders like build, dist, and Output are ignored from GitHub.

GitHub release

I created a GitHub release and attached the installer:

Windows11Alert_Setup.exe

This makes it easy for anyone to download and install the app.

Release page:

https://github.com/TutorialsAndroid/Windows11Alert/releases/latest

What I learned

This project taught me a lot about how Windows behaves during startup and shutdown.

The biggest lesson was:

Do not depend on network operations during shutdown.

Even if a shutdown script works manually, it may fail during actual shutdown because Windows is already closing services.

Reading shutdown events on the next startup is a much more reliable approach.

I also learned that building a complete desktop utility is not only about writing the Python code.

A polished tool also needs:

Installer
Uninstaller
Startup registration
Credential handling
Logs
Documentation
Release assets
GitHub README

Limitations

Windows11Alert has some limitations:

It is Windows-only
Instant shutdown-time Telegram alerts are not guaranteed
Unexpected power loss may not always create a clean shutdown event
Telegram credentials are stored locally

For personal monitoring, this setup works well.

For production or enterprise-level monitoring, a proper background service and backend-based architecture would be better.

Future improvements

Some ideas I may add later:

System tray icon
Encrypted local config
Telegram test button during setup
Discord webhook support
Email alert support
Daily summary report
Windows service version
Better installer UI

Download

You can download the latest Windows installer here:

https://github.com/TutorialsAndroid/Windows11Alert/releases/latest

Contributions are welcome

Contributions, suggestions, and bug reports are welcome.

You can help by:

Opening issues
Suggesting features
Improving documentation
Refactoring code
Adding notification platforms
Improving installer/uninstaller behavior

Final thoughts

Windows11Alert started as a small Python experiment, but it became a complete Windows utility with Telegram integration, startup monitoring, Windows Event Log reading, EXE packaging, installer support, and uninstall cleanup.

It is a good reminder that practical projects do not always need to be huge.

Sometimes a useful tool is just a small idea executed properly.

Windows11Alert tells you when your PC starts and what happened before it did.

How I Built a Native Video Compressor for 30 GB+ Files Using FFmpeg and Electron

Akshay — Wed, 13 May 2026 09:51:14 +0000

Online video compressors are great — until you hit a 35 GB file and watch the upload bar crawl to 1% before timing out.

I needed a tool that could handle raw production footage without ever sending it over the network.

So I built VideoSquash Pro — a free, open-source desktop app that runs FFmpeg natively on your Windows machine.

In this post, I’ll walk through the architecture, the tech stack, and how you can use or contribute to the project.

Architecture at a Glance

The app consists of three main layers:

1. Electron

Electron hosts the UI using HTML, CSS, and JavaScript.

It also manages the native child process that runs FFmpeg in the background.

2. FFmpeg Binary

FFmpeg is the real compression engine.

Instead of relying on browser-based encoding, VideoSquash Pro spawns a native FFmpeg binary with precise arguments based on the selected settings.

3. IPC Bridge

The IPC bridge streams real-time progress from FFmpeg to the renderer using Electron’s ipcMain, ipcRenderer, and preload setup.

This allows the UI to stay responsive while FFmpeg works in the background.

All processing happens offline.

No internet connection is needed after the initial download.

What You Can Control

The UI provides an industry-standard preset system plus full manual control over every FFmpeg parameter.

Developers will appreciate that it does not hide the complexity.

// Example of the FFmpeg spawn process, simplified

const args = [
  "-y",
  "-i",
  inputPath,

  "-c:v",
  "libx264",

  "-crf",
  "30",

  "-vf",
  "scale='min(1920,iw)':'min(1920,ih)':force_original_aspect_ratio=decrease",

  "-c:a",
  "aac",

  "-b:a",
  "128k",

  "-movflags",
  "+faststart",

  outputPath,
];

const proc = spawn(ffmpegPath, args);

proc.stdout.on("data", (data) => {
  // Parse progress data and send it to the renderer
});

The app supports control over:

Codec
CRF quality
Resolution
Output format
Audio settings
Compression presets

The goal is simple:

Give beginners easy presets, but still give developers real control.

Real-Time Progress Tracking

One thing I did not want was a fake progress bar.

So VideoSquash Pro uses ffprobe to get the exact duration of the input video.

Then, while FFmpeg is running, the app parses FFmpeg’s structured progress output and reads values like out_time_ms.

That value is compared against the total duration to calculate a real percentage from 0 to 100.

const progress = (currentTimeMs / totalDurationMs) * 100;

This gives users a progress bar that actually represents the compression process.

Why Not FFmpeg.wasm?

FFmpeg.wasm is amazing for browser-based video tools.

But for very large files, it has serious limitations.

Browser-based FFmpeg runs inside WebAssembly memory limits, which makes it unsuitable for huge files like 10 GB, 30 GB, or 50 GB videos.

Native FFmpeg is different.

It streams directly from disk.

It does not load the entire video into RAM.

That is the main reason VideoSquash Pro can handle very large files without crashing the browser or hitting memory limits.

How to Try It

You can download the pre-built Windows installer from the latest release:

https://github.com/TutorialsAndroid/video-squash-pro/releases/latest

Or you can clone the repo and run it locally.

git clone https://github.com/TutorialsAndroid/video-squash-pro.git
cd video-squash-pro
npm install
npm start

You will need to provide your own ffmpeg.exe and ffprobe.exe inside the assets/ folder if you are building it manually.

The entire source code is open source and MIT licensed.

Pull requests are welcome.

What’s Next?

I am planning to add:

Persistent preset saving
Hardware acceleration for Intel QSV and NVIDIA NVENC
Automatic file queuing
Multi-threaded compression
macOS and Linux builds

If any of these features interest you, or if you have other ideas, feel free to open an issue or drop a comment.

Links

Landing page:
https://tutorialsandroid.github.io/video-squash-pro/

GitHub Repo:
https://github.com/TutorialsAndroid/video-squash-pro

Download Installer:
https://github.com/TutorialsAndroid/video-squash-pro/releases/latest

If you have ever hit a wall with online video compressors, give VideoSquash Pro a try.

And if you are a developer, I would love to hear your thoughts on the architecture.

Drop a comment below.

Dev.to Tags

electron ffmpeg opensource javascript desktop windows productivity

I Built a Free Privacy-Focused Bulk Image Compressor That Runs Entirely in Your Browser

Akshay — Thu, 07 May 2026 06:50:05 +0000

I created a polished Medium-style version already. Here’s a DEV.to optimized version — more developer-focused, slightly more technical, cleaner formatting, and written in a style that performs well on DEV Community.

Compress massive images without uploading anything to a server

Every developer eventually runs into this problem.

You have:

Huge product photos
Design assets from Figma
DSLR images
Screenshots for documentation
Client uploads that are absurdly large

And suddenly:

Your CMS rejects uploads
Your website becomes slow
Your Git repository balloons in size
Your email attachment limit explodes

So you search for an “online image compressor”.

Then comes the part nobody talks about:

You’re uploading potentially sensitive files to random third-party servers.

I didn’t love that idea.

So I built ImageSquash Pro — a completely client-side bulk image compressor that works directly inside the browser.

No uploads.
No backend.
No analytics.
No tracking.

Just drag, drop, compress, and download.

🔥 Why I Built It

A client once sent me around 20 RAW product images.

The folder size?

~1.2 GB

They needed optimized versions for the web immediately.

Most online tools failed because they:

had file limits
required payment for batch processing
froze on large images
destroyed image quality
uploaded everything to their servers

So instead of fighting existing tools, I decided to build one optimized for:

privacy
speed
large batch processing
simplicity

That became ImageSquash Pro.

⚡ What Makes It Different

Most image compressors work like this:

Upload → Server Processing → Download

ImageSquash works like this:

Browser → Local Processing → Download

Everything happens directly on your machine using browser APIs.

That means:

✅ Your files never leave your computer
✅ No internet required after initial page load
✅ Compression happens locally on your CPU
✅ No waiting for uploads
✅ No privacy concerns

You can literally disconnect your WiFi and the app still works.

🖼️ Features

📦 Bulk Compression

Compress dozens of images at once.

No annoying “one file at a time” workflow.

🔒 Fully Private

No backend server.

No cloud processing.

No telemetry.

No analytics.

No hidden uploads.

🎛️ Adjustable Compression

Choose:

WebP
JPEG
PNG

And customize:

quality
dimensions
compression preset

📊 Compression Statistics

See:

original size
compressed size
savings percentage
total reduction

In real time.

📁 ZIP Export

Download the entire batch as a ZIP file.

One click.

⌨️ Keyboard Shortcuts

Ctrl + Enter → Compress All
Ctrl + D → Download ZIP

🛠️ Tech Stack

The project is intentionally simple.

No framework.

No build process.

No unnecessary dependencies.

Just browser APIs.

Built With

HTML5 Canvas API
FileReader API
JSZip
Vanilla JavaScript

🧠 Core Compression Logic

Here’s the simplified version:

const canvas = document.createElement("canvas");

canvas.width = targetWidth;
canvas.height = targetHeight;

const ctx = canvas.getContext("2d");

ctx.drawImage(img, 0, 0, targetWidth, targetHeight);

canvas.toBlob(
  (blob) => {
    // compressed image blob
  },
  "image/webp",
  0.35
);

The browser handles resizing and re-encoding completely locally.

No server involved.

📉 Real Compression Results

One test batch:

Original	Compressed
1.62 GB	4.21 MB

Single images around 80MB often compress down to roughly 200KB depending on settings.

Perfect for:

websites
portfolios
blogs
ecommerce
documentation
web apps

🔐 Why Privacy Matters

A surprising number of image tools upload files silently.

That’s risky when working with:

client assets
confidential documents
medical files
legal paperwork
internal company screenshots

I wanted a tool where privacy wasn’t just a policy.

I wanted privacy enforced by architecture.

With ImageSquash:

The safest upload is the one that never happens.

🚀 Live Demo

https://tutorialsandroid.github.io/image-squash-pro/

💻 GitHub Repository

https://github.com/TutorialsAndroid/image-squash-pro

📌 Future Improvements

Things I’d love to add:

AVIF support
HEIC support
Web Workers for background compression
Drag-to-reorder batches
GPU acceleration experiments
Folder upload support

🤝 Open Source

Contributions are welcome.

If you have ideas, optimizations, or feature suggestions, feel free to open an issue or submit a PR.

Final Thoughts

I originally built this as a utility for myself.

But it became something much more useful:

A fast, lightweight, privacy-focused tool that solves a real problem without forcing users to trust a random server.

And honestly, I think more web apps should work this way.

I built a Modern Android Toast Library that works properly on Android 11+ (with icons, colors & Version Catalog support)

Akshay — Tue, 28 Apr 2026 11:41:55 +0000

🚀 I built a Modern Android Toast Library that works properly on Android 11+ (with icons, colors & Version Catalog support)

Android’s default Toast customization stopped working reliably after Android 11 (API 30).
Setting background colors directly on Toast views is now restricted — which makes many old solutions break.

So I built a lightweight modern alternative:

👉 Toast Library

It provides:

✅ Success / Error / Info / Default variants
🎨 Colored rounded backgrounds
🧩 Built-in vector icons
📍 Gravity control (TOP / CENTER / BOTTOM)
📦 JitPack installation
🧰 Version Catalog support (latest Android Studio)
⚡ Lightweight & dependency-free

📦 Installation (JitPack)

Step 1 — Add JitPack repository

Inside settings.gradle.kts

pluginManagement {
    repositories {
        google()
        mavenCentral()
        maven("https://jitpack.io")
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)

    repositories {
        google()
        mavenCentral()
        maven("https://jitpack.io")
    }
}

⭐ Recommended: Version Catalog setup (Latest Android Studio)

Inside:

gradle/libs.versions.toml

Add:

[versions]
toastlib = "v2.0.0"

[libraries]
toastlib = { module = "com.github.TutorialsAndroid:Toast-Library", version.ref = "toastlib" }

Then inside:

app/build.gradle.kts

dependencies {
    implementation(libs.toastlib)
}

Alternative: Direct dependency

dependencies {
    implementation("com.github.TutorialsAndroid:Toast-Library:v2.0.0")
}

🚀 Usage Examples

Success Toast

ToastLib.success(this, "Saved successfully");

Error Toast

ToastLib.error(this, "Something went wrong");

Info Toast

ToastLib.info(this, "Welcome back!");

Default Toast

ToastLib.show(this, "Default toast");

📍 Custom Position Example

ToastLib.show(
        this,
        "Top message",
        ToastLib.ToastType.INFO,
        Gravity.TOP
);

📱 Why this library exists

Older approaches:

toast.getView().setBackgroundColor(...)

no longer work consistently on modern Android versions.

This library solves that using:

✔ custom layouts
✔ vector icons
✔ Material-style backgrounds
✔ Android 11+ compatibility

📦 GitHub Repo

⭐ Check it out here:

https://github.com/TutorialsAndroid/Toast-Library

Feedback and contributions welcome!

🛣 Roadmap

Next updates coming soon:

✨ toast animations
✨ builder pattern API
✨ dark mode support
✨ custom icon support

If this helps your Android projects, consider giving the repo a ⭐

Introducing KAlert.js — A lightweight animated alert dialog library for JavaScript

Akshay — Tue, 28 Apr 2026 07:41:27 +0000

Introducing KAlert.js — A Lightweight Modern Alert Dialog Library for JavaScript 🚀

While working on my frontend projects, I often needed a clean and modern alternative to the default browser alert dialogs.

The native browser alert:

alert("Hello world");

is functional, but it looks outdated and isn't customizable.

So I built KAlert.js — a lightweight, animated, Promise-based alert dialog library that works instantly via CDN with zero setup required.

✨ Features

KAlert.js provides:

✅ Animated modal dialogs
✅ Promise-based confirm dialogs
✅ Font Awesome icon support (auto-loaded)
✅ Blur background overlay
✅ Success / error / warning / info alert types
✅ Zero dependencies
✅ CDN-ready usage
✅ Lightweight and fast

📦 Install via CDN (No setup required)

Just include one script:

<script src="https://cdn.jsdelivr.net/gh/TutorialsAndroid/KAlert@v1.1.1/kalertdialog.js"></script>

That’s it.

No configuration needed.

🚀 Basic Usage Example

Show a success alert:

KAlert.show("Saved successfully!", "success");

Other supported alert types:

success
error
warning
info

Example:

KAlert.show("Something went wrong!", "error");

✅ Confirm Dialog Example (Promise-Based)

Unlike traditional confirm dialogs, KAlert uses a modern Promise API:

KAlert.confirm("Delete this file?")
.then(result => {

if(result){
console.log("User confirmed");
}else{
console.log("User cancelled");
}

});

This makes it easier to integrate into modern JavaScript workflows.

🎨 Alert Types Available

KAlert currently supports:

🟢 success
🔴 error
🟡 warning
🔵 info

Each alert includes animated UI and Font Awesome icons automatically.

💡 Why I Built This Library

Many alert dialog libraries are powerful but often:

• too large
• require configuration
• need multiple imports
• depend on frameworks

KAlert.js focuses on simplicity:

One script.
Instant usage.
Clean UI.

🧪 Live Example

KAlert.show("Welcome to KAlert!", "info");

KAlert.confirm("Continue?")
.then(result => console.log(result));

📂 GitHub Repository

You can check out the project here:

https://github.com/TutorialsAndroid/KAlert

Feedback, suggestions, and contributions are welcome!

🛠 Roadmap

Planned features for upcoming versions:

• custom dialog titles
• input prompt dialogs
• dark mode support
• theme customization
• button text customization

If you’re building frontend projects and want a clean alert dialog alternative without extra setup, give KAlert.js a try.

I’d love to hear your feedback 🙂

DEV Community: Akshay

KAlertDialog: A Beautiful Material Alert Dialog Library for Android

KAlertDialog: A Beautiful Material Alert Dialog Library for Android

What is KAlertDialog?

Why I Built It

Installation

Basic Usage

Success Dialog

Error Dialog

Warning Dialog

Progress Dialog

Input Field Dialog

Custom Image Dialog

URL Image Dialog

Dark Mode Support

Custom Button Drawable

Change Font

Change Text Colors

Change Content Alignment

Hide Confirm or Cancel Button

Change Alert Type Dynamically

Main Features

When Should You Use It?

GitHub Repository

Final Thoughts

I Built Windows11Alert — A Windows Utility That Sends Telegram Alerts When My PC Turns On

What Windows11Alert does

Example Telegram message

Why I built it

Tech stack

Telegram bot setup

Keeping credentials safer with .env

Auto-start using Windows Registry

Reading shutdown events from Windows Event Logs

Packaging the app with PyInstaller

Creating a Windows installer with Inno Setup

Project structure

GitHub release

What I learned

Limitations

Future improvements

Download

Contributions are welcome

Final thoughts

How I Built a Native Video Compressor for 30 GB+ Files Using FFmpeg and Electron

Architecture at a Glance

1. Electron

2. FFmpeg Binary

3. IPC Bridge

What You Can Control

Real-Time Progress Tracking

Why Not FFmpeg.wasm?

How to Try It

What’s Next?

Links

Dev.to Tags

I Built a Free Privacy-Focused Bulk Image Compressor That Runs Entirely in Your Browser

Compress massive images without uploading anything to a server

🔥 Why I Built It

~1.2 GB

⚡ What Makes It Different

🖼️ Features

📦 Bulk Compression

🔒 Fully Private

🎛️ Adjustable Compression

📊 Compression Statistics

📁 ZIP Export

⌨️ Keyboard Shortcuts

🛠️ Tech Stack

Built With

🧠 Core Compression Logic

📉 Real Compression Results

🔐 Why Privacy Matters

🚀 Live Demo

💻 GitHub Repository

📌 Future Improvements

🤝 Open Source

Final Thoughts

I built a Modern Android Toast Library that works properly on Android 11+ (with icons, colors & Version Catalog support)

🚀 I built a Modern Android Toast Library that works properly on Android 11+ (with icons, colors & Version Catalog support)

Keeping credentials safer with `.env`