Forem: Mate Technologies

I Built a Professional ZIP Converter Desktop App in Python 🚀

Mate Technologies — Mon, 25 May 2026 14:20:32 +0000

Just finished building ZIP Converter Pro — a modern Python desktop application for converting ZIP archives into multiple compression formats including TAR.GZ, TGZ, TAR, GZ, 7Z, and RAR.

🔥 Features:
• Drag & Drop ZIP importing
• Batch archive conversion
• Real-time progress tracking
• Pause / Resume / Stop controls
• Offline desktop utility
• Modern ttkbootstrap UI
• Multithreaded processing
• Auto-open output folders
• Smart archive extraction system

🛠 Built With:
Python • Tkinter • ttkbootstrap • threading • zipfile • tarfile • subprocess

This project was focused on creating a professional-grade compression workflow tool with a clean modern interface and high-performance archive processing.

📦 Download ZIP Converter Pro:
https://matetools.gumroad.com/l/xqtruh

Would love feedback from the Python community 👀

python #gui #desktop #tkinter #opensource #programming #productivity #100daysofcode #developers

🖼️ Build a Desktop Image-to-PDF Converter in Python (Tkinter + ttkbootstrap)

Mate Technologies — Sat, 23 May 2026 11:44:07 +0000

A practical Python project to build a modern desktop GUI app that converts multiple images into a single PDF file — with batch processing, file ordering, and a clean UI.

We’ll build CANVAPDF LITE, a lightweight offline tool using:

Tkinter (GUI)
ttkbootstrap (modern UI styling)
Pillow (image processing)
threading + queue (smooth background processing)

🔗 Pro Version / Source & Upgrade:
https://matetools.gumroad.com/l/canva-pdf-pro

🚀 What You Will Build

By the end of this tutorial, you’ll have:

A desktop GUI app for image-to-PDF conversion
Drag-free file management (add files/folders)
Manual ordering system (move up/down)
Background processing (no UI freezing)
Live progress tracking
About window + menu system
🧠 Project Architecture Overview

This app is structured into clear sections:

UI Layer (Tkinter + ttkbootstrap)
File Management System
Image Processing Engine (Pillow)
Thread Worker (background task)
Queue-based UI updater
📦 Step 1: Install Dependencies

pip install pillow ttkbootstrap

⚙️ Step 2: Initialize the App

We start by setting up the main window using a modern theme:

app = tk.Tk()
style = tb.Style("superhero")

app.title("CANVAPDF LITE v1.1.0")
app.geometry("1100x680")
app.minsize(900, 650)

👉 ttkbootstrap gives Tkinter a modern UI instantly.

📂 Step 3: File Handling System

We store selected images globally:

selected_files = []
SUPPORTED_FORMATS = (".png", ".jpg", ".jpeg")
Add Files
files = filedialog.askopenfilenames(
    filetypes=[("Images", "*.png *.jpg *.jpeg")]
)

Add Folder (Batch Import)

We scan directories using os.walk():

for root, _, files in os.walk(folder):
    for name in files:
        p = Path(root) / name

🧾 Step 4: Display File List in UI

We update the listbox dynamically:

file_listbox.delete(0, "end")

for f in selected_files:
    file_listbox.insert("end", os.path.basename(str(f)))

🔼 Step 5: Move Files Up & Down

We allow manual ordering:

selected_files[i], selected_files[i - 1] = selected_files[i - 1], selected_files[i]

This is useful when ordering pages in the final PDF.

🖼️ Step 6: Image to PDF Conversion Engine

Each image is opened and converted:

def open_image(path):
    return Image.open(path).convert("RGB")

Then we combine everything:

images[0].save(
    save_path,
    save_all=True,
    append_images=images[1:]
)

👉 This is the core of the PDF generator.

🧵 Step 7: Run Processing in Background Thread

To avoid UI freezing:

threading.Thread(target=worker, daemon=True).start()

Why this matters:

Tkinter runs on a single thread
Heavy tasks freeze UI unless threaded
📊 Step 8: Live Progress Updates (Queue System)

We safely update UI from worker thread:

ui_queue.put((cmd, data))

Then UI listens every 100ms:

app.after(100, process_queue)

⛔ Step 9: Stop Functionality

We allow canceling the process:

stop_event.set()

This helps users stop long conversions safely.

🎨 Step 10: Modern UI Features

Using ttkbootstrap we add:

Buttons with styles
Progress bars
Status indicators
Clean layout system

Example:

tb.Button(actions, text="🚀 Generate PDF", bootstyle="success")
ℹ️ Step 11: About Window

We added a full About dialog:

App info
Features list
Store link button
🛒 Project Link (Pro Version)

👉 Upgrade / Download / Support:
https://matetools.gumroad.com/l/canva-pdf-pro

🎯 Final Result

You now have a fully working:

✔ Desktop PDF generator
✔ Batch image importer
✔ Reorder system
✔ Thread-safe GUI
✔ Modern Tkinter UI

🧠 What You Learned
Tkinter GUI structure
File system integration
Pillow image processing
Multithreading in desktop apps
Queue-based UI updates
Modern Python desktop design patterns

CANVAPDF LITE — A Lightweight Python Tkinter Tool to Convert Images into PDFs (Fast Batch GUI App)

Mate Technologies — Sat, 23 May 2026 11:24:59 +0000

Build a fast, offline desktop app to convert images into PDFs using Python! 🚀

CANVAPDF LITE is a lightweight GUI tool built with Tkinter, ttkbootstrap, and Pillow, designed for quickly converting multiple images into a single PDF file with a clean and simple workflow.

🔗 Try Pro Version / Full Tool:
https://matetools.gumroad.com/l/canva-pdf-pro

⚡ Key Features
📄 Convert PNG / JPG / JPEG images into a single PDF
📁 Batch import files or entire folders
🔼 Reorder images manually (Up / Down controls)
🧵 Background threading for smooth UI experience
📊 Live progress tracking with queue-based updates
🪶 Lightweight, offline-first desktop application
🎨 Modern UI powered by ttkbootstrap themes
🧠 Tech Stack
Python 3
Tkinter (GUI framework)
ttkbootstrap (modern UI styling)
Pillow (image processing)
Threading + Queue (async task handling)
💡 Why This Project Matters

This project demonstrates how to build a production-style desktop utility using Python with:

Responsive GUI design (no freezing UI)
Batch file processing system
Thread-safe communication between worker and UI
Clean architecture for small productivity tools

Perfect for beginners learning GUI development or developers building lightweight desktop utilities.

ZIPMATE LITE — Free Offline ZIP Compression Tool Built with Python

Mate Technologies — Thu, 21 May 2026 08:13:40 +0000

ZIPMATE LITE is a lightweight offline ZIP compression utility built with Python, Tkinter, and ttkbootstrap.

Features:
• Compress files and folders into ZIP archives
• Fast and lightweight desktop application
• Beginner-friendly modern UI
• Progress tracking and compression logs
• Custom archive naming support
• Fully offline — no internet required

Built using:
Python • Tkinter • ZIPFILE • ttkbootstrap

Download EXE:
https://matetools.gumroad.com/l/wlfuqp

🚀 Build a Powerful Image Converter with Python (SnapConvert)

Mate Technologies — Wed, 06 May 2026 14:12:00 +0000

Looking for a fast, clean, and feature-rich way to convert images in bulk using Python? In this tutorial, we’ll walk through SnapConvert, a desktop application that lets you convert, resize, and manage images with ease.

👉 Get the full project here: https://gum.new/gum/cmjz96c0w001304jvdjdoaeuc

📸 What is SnapConvert?

SnapConvert is a Python-based GUI tool built with Tkinter, ttkbootstrap, and Pillow that allows you to:

Convert images between formats (PNG, JPEG, BMP, GIF)
Batch process multiple images or entire folders
Resize images quickly
Adjust JPEG quality
Drag & drop files into the app
Track conversion history using SQLite
Preview converted images instantly
🧰 Tech Stack

Here’s what powers SnapConvert:

Tkinter + ttkbootstrap → Modern UI
Pillow (PIL) → Image processing
SQLite3 → Conversion history
Threading → Smooth, non-blocking UI
TkinterDnD2 → Drag & drop support
🧠 Key Features Breakdown

📂 Flexible Image Input

You can:

Select individual images
Load entire folders
Or simply drag-and-drop files into the window

Supported formats:

.png, .jpg, .jpeg, .bmp, .gif

⚙️ Smart Conversion Options

SnapConvert gives you full control:

Output format (PNG, JPEG, BMP, GIF)
JPEG quality (10–100)
Resize images (set pixel size or keep original)
Filename control
Keep original names
Or auto-number outputs

🚀 Batch Processing with Threads

Conversions run in a separate thread, so the UI stays responsive.

thread = Thread(
    target=convert_images_worker,
    args=(...)
)
thread.start()

This means no freezing—even with large batches.

📊 Progress Tracking

A real-time progress bar updates as images are processed:

progress_callback(int((i+1)/len(images)*100))

🗂 Conversion History (SQLite)

Every conversion is stored in a local database:

CREATE TABLE images (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    filename TEXT,
    original_path TEXT,
    converted_path TEXT
)

You can:

View all past conversions
Double-click to preview images
Clear history anytime

🧹 File & History Management

SnapConvert separates:

History deletion (keeps files)
File deletion (keeps history)

This gives you full control over your workspace.

🖼 Instant Preview

Double-click any entry in the table to open the converted image using your system viewer:

os.startfile(path) # Windows
🧩 Core Conversion Logic

Here’s the heart of the app:

img = Image.open(img_path)

if resize > 0:
    img = img.resize((resize, resize), Image.ANTIALIAS)

img.save(output_path, output_format.upper(), **save_params)

It handles:

Resizing
Format conversion
Quality adjustments (JPEG)
🎯 User Experience Highlights
Clean dark UI using ttkbootstrap
Drag-and-drop support across the entire window
Modal help guide built into the app
Auto-created output directory
Cross-platform folder opening (Windows/macOS/Linux)
🧪 How to Run the App
Install dependencies:
pip install pillow ttkbootstrap tkinterdnd2
Run the script:
python snapconvert.py
💡 Ideas for Improvement

Want to take it further?

Add WebP support
Enable custom width/height resizing (not just square)
Add watermarking
Export history to CSV
Add dark/light theme toggle
🏁 Final Thoughts

SnapConvert is a great example of how you can combine Python + GUI + image processing into a practical desktop tool.

Whether you're a developer or just someone who works with images often, this project is a solid foundation to build upon.

👉 Download & explore the full project:
https://gum.new/gum/cmjz96c0w001304jvdjdoaeuc

⚙️ Enterprise Bulk Rename — Ultimate Edition (Python GUI Tool)

Mate Technologies — Mon, 04 May 2026 14:07:00 +0000

Renaming files one by one is painful.
Renaming hundreds (or thousands)? That’s a nightmare.

So I built a powerful, enterprise-grade bulk renaming tool in Python — with preview, undo, conflict resolution, and even force renaming.

👉 Get the full tool here: https://gum.new/gum/cmjzyahd9001n04l4fmdwbz24

🚀 What Makes This Tool Different?

This isn’t just another “rename files” script. It’s designed like a professional desktop utility.

🛠 Key Features
✅ Batch rename thousands of files safely
⚡ Real-time preview before applying changes
🔁 Undo system with batch tracking (SQLite powered)
🧠 Smart conflict resolution (auto-renames duplicates)
💪 Force rename locked/restricted files
🖱 Drag & drop support
📂 Folder + recursive file selection
📊 Progress bar + cancel operation
📁 Export rename history to CSV
🧠 Smart Rename Patterns

The tool supports dynamic placeholders so you can generate powerful naming schemes:

Placeholder Description
{name} Original filename
{ext} File extension
{num} Auto-increment number
{date} Last modified date
{uuid} Random unique ID
💡 Examples
file_{num}{ext}

→ file_001.jpg

file_{num}_{name}{ext}

→ file_001_vacation.jpg

{name}_backup{ext}

→ vacation_backup.jpg

🖼️ How It Works (Workflow)
Select files / folders OR drag & drop
Enter your rename pattern
Preview changes instantly
Fix conflicts automatically
Click Rename
Undo anytime if needed
🔄 Undo System (Game-Changer)

Every rename operation is stored in a SQLite database.

That means:

You can undo entire batches
Track rename history
Export logs to CSV

def undo_batch(batch_id):
    with sqlite3.connect(DB_NAME) as conn:
        rows = conn.execute("""
            SELECT folder, original_name, new_name
            FROM rename_history
            WHERE batch_id=?
            ORDER BY id DESC
        """, (batch_id,)).fetchall()

⚙️ Conflict Resolution Engine

No more “file already exists” errors.

The tool automatically detects duplicates and resolves them:

while (folder, candidate) in seen or os.path.exists(os.path.join(folder, candidate)):
    candidate = f"{base}({i}){ext}"

✔ Example:

file_001.jpg
file_001(1).jpg
file_001(2).jpg
💪 Force Rename Mode

Sometimes files are:

Locked
Read-only
Restricted

Enable Force Rename to override safety checks.

⚠️ A warning indicator highlights risky operations in red.

🧵 Multithreaded Performance

Renaming runs in a background thread, so your UI never freezes:

class RenameWorker(threading.Thread):
    def run(self):
        for i, (folder, old, new) in enumerate(self.rows):
            os.rename(...)

✔ Smooth
✔ Responsive
✔ Cancel anytime

🖥️ Built With
🐍 Python
🎨 Tkinter + ttkbootstrap
🗂 SQLite
🧵 Threading
🎯 Why I Built This

I needed a tool that could:

Handle large batches
Avoid naming conflicts
Provide undo safety
Feel like a real desktop app

So I built one — and made it better than most free tools out there.

📦 Get the Tool

If you want the full working version:

👉 https://gum.new/gum/cmjzyahd9001n04l4fmdwbz24

💡 Final Thoughts

If you’re dealing with:

Media files
Data exports
Project assets
Backups

This tool can save you hours of manual work.

📋 Build a Powerful Clipboard Manager in Python (With GUI, History, Search & Tray Support)

Mate Technologies — Sat, 02 May 2026 14:03:00 +0000

If you’ve ever copied something important… and then lost it after copying something else — you know the pain.

So I built a full-featured Clipboard Manager using Python that tracks, stores, and lets you manage everything you copy — with a modern UI and powerful features.

👉 Get the full project here:
https://gum.new/gum/cmjzhtctz000404l8a0v5fyvo

🚀 What This App Can Do

This isn’t just a basic clipboard tracker — it’s a productivity tool:

📋 Automatically saves clipboard history
🔍 Real-time search & highlighting
🧠 Smart multi-line preview
🖱 Right-click context actions (copy, save, delete)
📦 Export / Import clipboard data (JSON)
⚙ Adjustable history size limit
🖥 System tray integration
⌨ Global hotkey: Ctrl + Shift + V
🔄 Drag & reorder clipboard items
👀 Full preview popup for long content
🧱 Tech Stack

Built using:

ttkbootstrap → modern UI styling
tkinter → GUI foundation
sqlite3 → persistent storage
pyperclip → clipboard access
keyboard → global hotkeys
pystray → system tray integration
threading → background clipboard monitoring
🧠 How It Works

Clipboard Monitoring (Background Thread)

The app continuously checks your clipboard:

def poll_clipboard(self):
    while self.running:
        try:
            text = pyperclip.paste()
        except Exception:
            text = ""
        if text and text != self.last_text:
            self.last_text = text
            self.save_item(text)
        time.sleep(POLL_INTERVAL)

This ensures:

No duplicates
Real-time capture
Smooth performance

Persistent Storage with SQLite

Every clipboard entry is saved locally:

CREATE TABLE clipboard (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    content TEXT UNIQUE,
    timestamp REAL
)

Why SQLite?

Lightweight
Fast
No external dependencies

Smart Preview System

Instead of flooding the UI with long text:

lines = content.splitlines()
display = "\n".join(lines[:3])
if len(lines) > 3:
    display += " …"

✔ Clean
✔ Readable
✔ Efficient

Search + Highlight

The search bar filters instantly:

if query and query in content.lower():
    self.tree.item(iid, tags=("highlight",))

With visual highlighting for matched results.

Drag-to-Reorder History

Reorganize your clipboard manually:

def drop(self, event):
    items = self.tree.get_children()
    now = time.time()
    for i, item in enumerate(items):
        cursor.execute("UPDATE clipboard SET timestamp=? WHERE id=?", (now - i, item))

This reassigns timestamps to reflect the new order.

System Tray + Hotkey

Run the app silently in the background:

keyboard.add_hotkey("ctrl+shift+v", self.toggle_window)

Tray menu includes:

Show / Hide
Quit

Export / Import Clipboard Data

Save your history:

json.dump(data, f)

Or restore it later:

data = json.load(f)
for text in data:
    self.save_item(text)

Perfect for:

Backups
Migration
Sharing snippets
🎯 Why This Project Matters

This project demonstrates how to:

Build a real-world desktop tool
Combine UI + background processing
Use local databases effectively
Implement system-level integrations

It’s a great example of turning Python into a daily productivity app.

🖥 UI Highlights
Dark themed interface (via ttkbootstrap)
Scrollable history list
Context menus
Popup previews
Settings dialog
⚙️ Customization Ideas

Want to extend it further?

🔐 Add encryption for sensitive clips
☁ Cloud sync (Firebase / API)
🏷 Tagging system
🧩 Plugin support
📸 Image clipboard support
🏁 Final Thoughts

This Clipboard Manager is something you’ll actually use daily — and it shows how powerful Python can be beyond scripts.

If you want the full working project with all features ready, grab it here:

👉 https://gum.new/gum/cmjzhtctz000404l8a0v5fyvo

🚀 PDFTextor — Extract Text from PDFs with a Modern Python GUI

Mate Technologies — Thu, 30 Apr 2026 13:59:00 +0000

Working with PDFs can be frustrating—especially when you just need the text quickly.

That’s why I built PDFTextor, a simple yet powerful desktop tool that lets you extract text from one or multiple PDF files with ease.

👉 Get it here: https://gum.new/gum/cmk3n0dst002504ky9ulpdf2u

✨ What is PDFTextor?

PDFTextor is a Python-based desktop application that allows you to:

Extract text from single or multiple PDF files
Handle large documents smoothly
Track progress in real time
Cancel extraction anytime
Save extracted text instantly

It’s lightweight, fast, and designed with a clean modern UI.

🔥 Key Features
📂 Multi-PDF Extraction

Select multiple PDF files and extract all text in one go.

⚡ Real-Time Progress Tracking

A progress bar shows exactly how far the extraction has gone.

❌ Cancel Anytime

Stop long operations instantly with a cancel button.

💾 Save Extracted Text

Export results to a .txt file with one click.

🧹 Clean & Reset

Clear the workspace instantly for a new session.

🎨 Modern UI

Built with ttkbootstrap for a sleek, professional look.

🧠 How It Works

PDFTextor uses:

PyPDF2 to read and extract text from PDF pages
Threading to keep the UI responsive
Tkinter + ttkbootstrap for the interface

The extraction runs in a background thread, so your app never freezes—even with large PDFs.

🖥️ Code Overview

Here’s the core structure of the app:

class PDFTextExtractor:
    def __init__(self, root):
        self.root = root
        self.root.title("PDFTextor - PDF Text Extractor")

📌 Extraction Logic

The heavy lifting happens in a worker thread:

def _extract_text_worker(self, file_paths):
    for file_path in file_paths:
        reader = PdfReader(file_path)
        for page in reader.pages:
            text += page.extract_text() or ""

📊 Progress Updates

def _update_progress(self, value):
    self.progress["value"] = value
    self.progress_label.config(text=f"Extracting... {int(value)}%")

❌ Cancel Support

if self.cancel_event.is_set():
    return

This ensures users can safely stop long-running tasks.

🧩 UI Highlights
Buttons for extract, save, clear, cancel
Scrollable text output area
Progress bar with status updates
Built-in About/Guide window

Everything is designed for simplicity and usability.

📦 Tech Stack
Python
Tkinter
ttkbootstrap
PyPDF2
Multithreading
💡 Why I Built This

Many PDF tools are either:

Too heavy
Too expensive
Or lack batch processing

PDFTextor solves all three problems with a clean, efficient solution.

🚀 Getting Started
Download the app
👉 https://gum.new/gum/cmk3n0dst002504ky9ulpdf2u
Run the application
Click "Extract PDF Text"
Select your PDF files
Sit back and let PDFTextor do the work
🛠️ Future Improvements
OCR support for scanned PDFs
Export to JSON / CSV
Drag & drop support
Dark mode toggle
👨‍💻 Developer

Built by MateTools
🌐 https://matetools.gumroad.com

⭐ Final Thoughts

If you regularly work with PDFs, PDFTextor can save you a ton of time.

Simple. Fast. Reliable.

Give it a try and let me know what you think!

👉 https://gum.new/gum/cmk3n0dst002504ky9ulpdf2u

🔐 FileCryptor – Secure File & Folder Encryption Tool (Python + GUI)

Mate Technologies — Tue, 28 Apr 2026 13:55:00 +0000

If you’ve ever needed a simple, secure way to encrypt files and folders, this project might be exactly what you’re looking for.

Introducing FileCryptor — a modern Python desktop app that lets you encrypt and decrypt files with strong password-based security, all wrapped in a clean GUI.

👉 Get it here: https://gum.new/gum/cmkncobmj001h04jr8ecl39l9

🚀 What is FileCryptor?

FileCryptor is a desktop encryption tool built with:

🐍 Python
🖼 Tkinter + ttkbootstrap UI
🔐 cryptography library (Fernet + PBKDF2HMAC)

It allows you to:

Encrypt files & folders recursively
Decrypt them safely with the same password
Use drag & drop for fast workflows
Monitor progress in real time
🔑 Why This Tool Matters

Security tools are often:

Too complex ❌
Too technical ❌
Or just ugly ❌

FileCryptor focuses on:

✔ Simplicity
✔ Strong encryption
✔ Clean UI
✔ Real usability

🔐 How Encryption Works

This tool uses industry-standard cryptography:

Password-Based Key Derivation Uses PBKDF2HMAC (SHA-256) 390,000 iterations Adds strong resistance against brute-force attacks
Random Salt Per File Each file gets a unique 16-byte salt Prevents identical files from producing identical outputs
Secure Encryption Uses Fernet (AES-based encryption) Ensures confidentiality + integrity ✨ Key Features 📁 Encrypt Entire Folders Recursively processes all files No need to manually select each file 🖱 Drag & Drop Support Just drop files/folders into the app Instant queueing 🔐 Password Protection Password confirmation dialog Strength indicator: Weak Medium Strong ⏱ Real-Time Progress Progress bar + logs Smooth UI thanks to threading ❌ Cancel Anytime Stop long operations safely 🧹 Clean Logs Built-in log viewer Clear logs with one click 💡 Example Workflow Drag a folder into FileCryptor Click Encrypt Files/Folders Enter a strong password Files are encrypted with .enc extension

Later:

Select encrypted files
Click Decrypt
Enter the same password
Files are restored 🎉
🧠 Smart Design Choices
🔄 Multithreading

Keeps the UI responsive during long operations.

🔍 Recursive File Handling

Automatically processes nested directories.

🛑 Safe Decryption
Skips invalid files
Prevents crashes on corrupted data
📦 Supported Files

Short answer: everything.

You can encrypt:

📄 Documents (PDF, DOCX, TXT)
🖼 Images (PNG, JPG)
🎵 Media (MP3, MP4)
💻 Code (PY, JSON, CSV)

If it’s a file → it works.

🛠 Tech Stack
Python 3
Tkinter
ttkbootstrap
cryptography
tkinterdnd2
🔥 Code Highlights
Secure Key Derivation

def derive_key(password: str, salt: bytes) -> bytes:
    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        iterations=390_000,
        backend=default_backend()
    )
    return base64.urlsafe_b64encode(kdf.derive(password.encode()))

Encryption Flow

salt = os.urandom(16)
key = derive_key(password, salt)
fernet = Fernet(key)
encrypted_data = fernet.encrypt(data)

Decryption Flow

salt = data[:16]
encrypted_data = data[16:]
key = derive_key(password, salt)
fernet = Fernet(key)
decrypted_data = fernet.decrypt(encrypted_data)

⚠️ Important Notes
🔑 If you lose your password → your data is gone
There is no recovery mechanism (by design, for security)
📥 Get FileCryptor

👉 Download here:
https://gum.new/gum/cmkncobmj001h04jr8ecl39l9

💬 Final Thoughts

FileCryptor is a great example of how you can combine:

Security 🔐
Usability 🧑‍💻
Clean UI 🎨

…into a practical tool people can actually use.

If you're building Python desktop apps, this project is also a solid reference for:

Tkinter architecture
Threading patterns
Real-world cryptography usage

🚀 KeySage – Keyword Suggester Pro (Google Autocomplete Scraper in Python)

Mate Technologies — Sun, 26 Apr 2026 13:32:00 +0000

If you're into SEO, content creation, or digital marketing, you already know one thing:

👉 Keywords are everything.

But finding high-quality, long-tail keywords manually? That’s slow and painful.

So I built KeySage – Keyword Suggester Pro — a fast, clean, and powerful desktop tool that pulls keyword ideas directly from Google Autocomplete.

🔗 Get KeySage Here

👉 https://gum.new/gum/cmk5ca5og002f04lbfga113vy

💡 What is KeySage?

KeySage is a lightweight Python desktop app that generates hundreds (or thousands) of keyword ideas using:

Google Suggest API
Smart expansion logic (A–Z, 0–9)
Phrase manipulation (prepend/append)
Real-time scraping UI

No login. No API keys. No fluff.

⚡ Core Features
🔍 1. Google Autocomplete Scraping

Pulls real-time keyword suggestions directly from Google’s suggestion engine.

def fetch_suggestions(query):
    params = {"client": "firefox", "q": query, "hl": language.get(), "gl": country.get()}
    r = requests.get(GOOGLE_SUGGEST_URL, params=params, headers=HEADERS, timeout=10)
    return r.json()[1]

🔤 2. A–Z Keyword Expansion

Automatically expands your base keyword:

keyword a
keyword b
...
keyword z
optionally 0–9

chars = list(string.ascii_lowercase)
if mode.get() == "A-Z + 0-9":
    chars += list(string.digits)

🧠 3. Phrase Modes (Smart Variations)

Generate smarter keyword combinations:

Exact → keyword a
Prepend → best keyword
Append → keyword tool

if phrase_mode.get() == "Prepend":
    query_list = [f"{w} {base}" for w in words]
elif phrase_mode.get() == "Append":
    query_list = [f"{base} {w}" for w in words]

🌍 4. Language & Country Targeting

Target keywords by region:

Language: en, fr, de, etc.
Country: US, UK, IN, etc.

Perfect for localized SEO research.

🔐 5. Proxy Support

Avoid rate limits or blocks by using a proxy:

def get_proxies():
    proxy_text = proxy_entry.get().strip()
    if proxy_text:
        return {"http": f"http://{proxy_text}", "https": f"http://{proxy_text}"}

📊 6. Keyword Clustering

Automatically groups keywords by root word:

def cluster_keywords():
    for k in results:
        root = k.split()[0].lower()
        clusters[root].append(k)

Example output:

[seo] seo tools, seo tips, seo checklist...
[python] python tutorial, python gui, python scraping...
📁 7. Export Options

Export your keyword data in:

✅ TXT (clustered)
✅ CSV (structured)
✅ JSON (developer-friendly)
⚙️ 8. Multithreaded Scraping

The UI stays responsive while scraping runs in the background:

threading.Thread(
    target=run_scraper,
    args=(base_keywords,),
    daemon=True
).start()

🖥️ User Interface Highlights
Clean UI powered by ttkbootstrap
Live keyword feed
Start / Stop controls
Advanced settings toggle
Built-in help guide
🧩 How It Works
Enter base keywords
Choose expansion mode (A–Z / A–Z + 0–9)
(Optional) Add prepend/append words
Hit Start Scraping
Watch live keyword results
Export when done
🛑 Smart Safeguards
Prevents export if scraping is incomplete
Allows safe stopping mid-process
Handles request errors gracefully
🧱 Tech Stack
Python
Tkinter + ttkbootstrap
Requests
Multithreading
🎯 Who Is This For?
SEO specialists
Bloggers & niche site builders
YouTubers
Affiliate marketers
Indie hackers
🚀 Final Thoughts

KeySage is built for speed, simplicity, and power.

Instead of paying monthly for keyword tools, you can:

✔ Generate unlimited ideas
✔ Customize queries
✔ Export structured data
✔ Stay fully offline (except scraping)

🔥 Download Now

👉 https://gum.new/gum/cmk5ca5og002f04lbfga113vy

Build a Beginner-Friendly Audio Splitter in Python 🎵

Mate Technologies — Sat, 25 Apr 2026 05:17:00 +0000

In this tutorial, we’ll create a simple desktop app to split audio files into smaller clips using Python. We’ll use Tkinter for the GUI and pydub for audio processing. By the end, you’ll have a fully functional audio splitter with progress updates and live logs.

You can see the full project here: AudioSplitter GitHub

1️⃣ Setup: Install Dependencies

First, make sure you have Python installed. Then, install the required libraries:

pip install pydub ttkbootstrap

Note: You also need FFmpeg installed. Download it from ffmpeg.org
and remember the path, e.g., C:\ffmpeg\bin.

2️⃣ Configure FFmpeg in Python

pydub needs FFmpeg to process audio. We also want to run it silently without opening extra windows.

import os
from pydub import AudioSegment
import subprocess

FFMPEG_DIR = r"C:\ffmpeg\bin"  # Update your FFmpeg path
os.environ["PATH"] = FFMPEG_DIR + os.pathsep + os.environ.get("PATH", "")

# Prevent command window popup on Windows
_original_popen = subprocess.Popen
def silent_popen(*args, **kwargs):
    kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
    return _original_popen(*args, **kwargs)
subprocess.Popen = silent_popen

AudioSegment.converter = os.path.join(FFMPEG_DIR, "ffmpeg.exe")
AudioSegment.ffprobe = os.path.join(FFMPEG_DIR, "ffprobe.exe")

✅ This ensures FFmpeg works silently in the background.

3️⃣ Import GUI & Helper Libraries

We will use Tkinter for the GUI and ttkbootstrap for styling. We also need threading for smooth UI updates.

import tkinter as tk
from tkinter import filedialog, messagebox
import ttkbootstrap as tb
from ttkbootstrap.widgets.scrolled import ScrolledText
import threading, math

4️⃣ Define App Metadata

It's good to have app information for "About" dialogs and branding.

APP_NAME = "Audio Splitter"
APP_VERSION = "1.1.0"
APP_AUTHOR = "MateTools"
APP_WEBSITE = "https://matetools.gumroad.com"

5️⃣ Setup Tkinter App

Create the main window and apply a theme from ttkbootstrap:

app = tk.Tk()
style = tb.Style(theme="superhero")

app.title(f"{APP_NAME} {APP_VERSION}")
app.geometry("950x600")

Optionally, set an icon:

try:
    app.iconbitmap("logo.ico")  # replace with your icon
except:
    pass

6️⃣ Helper Functions: UI & Logging

To safely update UI elements from threads, define a helper:

stop_event = threading.Event()

def ui(func, *args, **kwargs):
    app.after(0, lambda: func(*args, **kwargs))

def log_line(text):
    def _log():
        log.text.config(state="normal")
        log.text.insert("end", text + "\n")
        log.text.see("end")
        log.text.config(state="disabled")
    ui(_log)

7️⃣ Menus: Help & About

Add menus to show the user guide and about info:

def show_about():
    messagebox.showinfo(
        f"About {APP_NAME}",
        f"{APP_NAME} v{APP_VERSION}\n🔊 Split audio files fast!\n🌐 {APP_WEBSITE}"
    )

def show_help():
    messagebox.showinfo(
        f"{APP_NAME} - User Guide",
        "1️⃣ Select audio file\n2️⃣ Choose output folder\n3️⃣ Configure settings\n4️⃣ Start splitting"
    )

menubar = tb.Menu(app)
file_menu = tb.Menu(menubar, tearoff=0)
file_menu.add_command(label="Exit", command=app.quit)

help_menu = tb.Menu(menubar, tearoff=0)
help_menu.add_command(label="User Guide", command=show_help)
help_menu.add_command(label="About", command=show_about)

menubar.add_cascade(label="File", menu=file_menu)
menubar.add_cascade(label="Help", menu=help_menu)
app.config(menu=menubar)

8️⃣ GUI Layout: Input & Output

Create sections to select audio files and output folder, with options for prefix and clip length.

# Audio Input
audio_path = tk.StringVar()
input_card = tb.Labelframe(app, text="Audio Input", padding=15)
input_card.pack(fill="x", padx=10, pady=10)

tb.Entry(input_card, textvariable=audio_path).pack(side="left", fill="x", expand=True, padx=5)
tb.Button(input_card, text="Browse", bootstyle="info",
          command=lambda: audio_path.set(filedialog.askopenfilename(filetypes=[("Audio", "*.mp3 *.wav *.flac *.ogg")]))
         ).pack(side="left", padx=5)

# Output Settings
output_dir = tk.StringVar()
file_prefix = tk.StringVar(value="audio")
clip_length = tk.IntVar(value=10)

output_card = tb.Labelframe(app, text="Output Settings", padding=15)
output_card.pack(fill="x", padx=10, pady=10)

tb.Entry(output_card, textvariable=output_dir).pack(side="left", fill="x", expand=True, padx=5)
tb.Button(output_card, text="Browse", bootstyle="info",
          command=lambda: output_dir.set(filedialog.askdirectory())
         ).pack(side="left", padx=5)
tb.Label(output_card, text="Prefix:").pack(side="left", padx=5)
tb.Entry(output_card, textvariable=file_prefix, width=15).pack(side="left")
tb.Label(output_card, text="Seconds:").pack(side="left", padx=5)
tb.Entry(output_card, textvariable=clip_length, width=5).pack(side="left")

9️⃣ Preview: Show Clips & Duration

Automatically calculate how many clips will be created:

preview_label = tb.Label(output_card, text="Total: --s | Clips: --")
preview_label.pack(side="left", padx=10)

def update_preview(*args):
    try:
        audio = AudioSegment.from_file(audio_path.get())
        duration = len(audio) / 1000
        clips = math.ceil(duration / clip_length.get())
        preview_label.config(text=f"Total: {duration:.2f}s | Clips: {clips}")
    except:
        preview_label.config(text="Total: --s | Clips: --")

clip_length.trace_add("write", lambda *args: update_preview())
audio_path.trace_add("write", lambda *args: update_preview())

🔟 Log & Progress

Show live output and progress bar:

log_card = tb.Labelframe(app, text="Live Output", padding=15)
log_card.pack(fill="both", expand=True, padx=10, pady=10)

log = ScrolledText(log_card, height=10)
log.pack(fill="both", expand=True)
log.text.config(state="disabled")

progress = tb.Progressbar(app, maximum=100)
progress.pack(fill="x", padx=10, pady=5)

1️⃣1️⃣ Split Audio Function

The main function splits audio into clips and updates logs/progress:

def split_audio():
    if not audio_path.get() or not output_dir.get():
        messagebox.showerror("Error", "Select input and output")
        return

    stop_event.clear()
    ui(progress.configure, value=0)

    audio = AudioSegment.from_file(audio_path.get())
    total_ms = len(audio)
    step_ms = clip_length.get() * 1000
    total_clips = math.ceil(total_ms / step_ms)
    count = 0

    for i in range(0, total_ms, step_ms):
        if stop_event.is_set():
            log_line("⏹ Stopped by user")
            break

        chunk = audio[i:i+step_ms]
        filename = f"{file_prefix.get()}_{count:03d}.mp3"
        out_path = os.path.join(output_dir.get(), filename)
        chunk.export(out_path, format="mp3")

        count += 1
        progress_value = min((i + step_ms) / total_ms * 100, 100)
        ui(progress.configure, value=progress_value)

        log_line(f"Saved: {filename}")

    ui(progress.configure, value=100)
    messagebox.showinfo("Done", f"Created {count} clips")

1️⃣2️⃣ Start/Stop Buttons

Run the splitter in a separate thread to keep the GUI responsive:

bar = tb.Frame(app)
bar.pack(fill="x", padx=10, pady=5)

tb.Button(bar, text="Start", bootstyle="success",
          command=lambda: threading.Thread(target=split_audio, daemon=True).start()
         ).pack(side="left", padx=5)

tb.Button(bar, text="Stop", bootstyle="danger",
          command=lambda: stop_event.set()
         ).pack(side="left", padx=5)

1️⃣3️⃣ Run the App

Finally, start the Tkinter main loop:

app.mainloop()

✅ Congratulations! You now have a fully functional audio splitter with GUI, live logs, progress, and flexible output options.

🚀 VID2IMG Pro — Extract & Anonymize Video Frames Like a Pro

Mate Technologies — Fri, 24 Apr 2026 13:28:00 +0000

If you’ve ever needed to turn a video into high-quality images — whether for AI datasets, photogrammetry, or privacy-safe content — you know it’s not as simple as hitting “export frames.”

That’s exactly why I built VID2IMG Pro.

👉 Get it here: https://gum.new/gum/cmk5ut3j8000i04l1fdp098nh

🎯 What is VID2IMG Pro?

VID2IMG Pro is a powerful desktop application that lets you:

Extract frames from videos at custom intervals
Automatically anonymize faces and license plates
Generate clean datasets for AI or 3D reconstruction
Process 360° videos safely
Export optimized image sequences

All wrapped in a modern UI powered by ttkbootstrap.

🔥 Key Features
🎬 Smart Frame Extraction
Supports MP4, AVI, MOV
Custom frame intervals (e.g., every 10 frames)
Batch-ready workflow
🔒 Built-in Anonymization
Face detection + blur
License plate pixelation
Privacy-ready outputs for public datasets
🌍 360° Video Support
Handles equirectangular formats
Prevents distortion artifacts during processing
🧠 Photogrammetry Mode

Perfect for tools like:

Meshroom
RealityCapture
Metashape

Includes:

Lossless PNG output
Sequential naming
Consistent resolution
📊 Live Feedback UI
Real-time logging
Progress bar tracking
Thread-safe UI updates
🧩 Tech Stack

Here’s what powers VID2IMG Pro:

import tkinter as tk
import ttkbootstrap as tb
import cv2
import numpy as np
import threading
Tkinter + ttkbootstrap → Modern GUI
OpenCV → Video processing & detection
Multithreading → Smooth, non-blocking UI
⚙️ How It Works

Load a Video cap = cv2.VideoCapture(video_path.get())
Loop Through Frames ret, frame = cap.read()
Apply Anonymization (Optional) faces = face_cascade.detectMultiScale(gray, 1.2, 5) frame[y:y+h, x:x+w] = cv2.GaussianBlur(roi, (51, 51), 0)
Save Frames cv2.imwrite(path, frame)
Update UI Safely app.after(0, lambda: func(*args)) 💡 Real-World Use Cases 🤖 AI Dataset Creation

Extract labeled frames while anonymizing sensitive data.

🚁 Drone Footage Processing

Convert aerial video into usable still frames.

🏙️ Privacy-Compliant Recording

Blur faces and plates automatically for legal compliance.

🧱 3D Reconstruction

Generate perfect input for photogrammetry pipelines.

🖥️ UI Highlights
Clean two-panel layout
Live scrolling logs
Progress tracking
Built-in help guide
Start/Stop control with threading safety
🧠 Developer Notes

A few important design decisions:

Thread-safe UI updates using:
app.after(0, ...)
Graceful stop handling with:
stop_event = threading.Event()
Resource packaging support:
getattr(sys, '_MEIPASS', ...)

This makes it fully compatible with PyInstaller builds.

📦 Why This Tool Matters

Most frame extractors:

❌ Ignore privacy
❌ Lack automation
❌ Break on large workloads

VID2IMG Pro fixes that by combining:

Performance
Privacy
Professional workflow features
🚀 Try It Out

👉 Download VID2IMG Pro:
https://gum.new/gum/cmk5ut3j8000i04l1fdp098nh

💬 Final Thoughts

This project was built with real-world workflows in mind — not just as a utility, but as a production-ready tool.

If you’re working with:

AI
Video processing
Computer vision
3D reconstruction

…this will save you hours.