HEXT 2.0 Text to ASCII Banner Generator

cd HEXT

python3 -m venv venv
source venv/bin/activate

pip install -r requirements.txt
python3 hext.py

python3 hext.py

http://127.0.0.1:22800/

- Type text into the input field
- Select a font from the dropdown
- Click "Render"

- Click "Copy" to clipboard
- Click "Download" to save .txt file

MIT License

Copyright (c) 2025 Rob Seaverns

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights  
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
copies of the Software, and to permit persons to whom the Software is  
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in  
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  
DEALINGS IN THE SOFTWARE.

Looking for a fast, lightweight solution to browse and manage project directories? VoidCrawler Directory Browsing Utility is a single-file PHP application designed specifically for developers who want an offline, portable, and secure way to explore their project files.

VoidCrawler is built to run on any modern web server, including Apache, Nginx, or IIS, with PHP 7.4+. It leverages the browser’s FileReader API and drag-and-drop capabilities to provide instant directory tree rendering and file previews, all processed locally on your machine. This ensures complete privacy for sensitive repositories or personal projects.

VoidCrawler Directory Browsing Utility :

Before using the VoidCrawler Directory Browsing Utility, make sure your environment meets the following requirements. VoidCrawler is a PHP-based developer tool, so it needs a proper web server and modern browser capabilities to function correctly.

Web Server

VoidCrawler must run on a web server such as:

• Apache – widely used and highly compatible

• Nginx – lightweight and fast

• IIS – for Windows environments

PHP

Since voidcrawler.php is a PHP file, your server must have PHP installed:

• Recommended version: PHP 7.4+

• Ensure the fileinfo PHP extension is enabled for optimal file handling

Browser

VoidCrawler uses modern browser APIs for instant directory browsing. Make sure you are using a supported browser:

• FileReader API – required for reading local files

• Drag-and-drop folder parsing (webkitdirectory) – for folder uploads

• Compatible browsers include Chrome, Firefox, Edge, and Safari

⚠️ Important: VoidCrawler will not function properly without a web server and PHP. Opening the PHP file directly in a browser without a server may result in blank pages or errors.

By ensuring these prerequisites, you can fully leverage the VoidCrawler Directory Browsing Utility for offline, secure, and efficient file and directory management.

The application is extremely simple to set up. You only need the voidcrawler.php file and, optionally, a favicon.ico for branding. No installation, no dependencies, and no backend configuration are required. Just upload the file to your server, open it in a modern browser like Chrome, Firefox, Edge, or Safari, and start browsing your directories immediately.

VoidCrawler Directory Browsing Utility :

• Instant directory-tree rendering with collapsible subfolders

• Direct file previews without uploading or transmitting data

• Single-file deployment for maximum portability

• Dark, developer-friendly interface with clean, organized design

• Customizable and hackable for developer workflows

• Private offline repository browsing with hidden file/exclusion rules

Whether you are performing a code review, exploring documentation, or managing offline project files, VoidCrawler provides a convenient and secure solution for developers who value simplicity and speed.

For more information, updates, and downloads, visit K0NxT3D. VoidCrawler continues to evolve with new features, keeping developer productivity and privacy at the forefront.

Experience an effortless, drag-and-drop directory browsing experience today with the VoidCrawler Directory Browsing Utility, your portable developer CMS for all projects.

Latest Version 2.0.1 (Release)

VoidCrawler

Download

// default in index.php
$root = './';
$pathLen = strlen($root);
myScanDir($root, 0, strlen($root));

$root = '/var/www/data/archives/';

function myScanDir($dir, $level, $rootLen)
{
    global $pathLen;

    if ($handle = opendir($dir)) {
        $allFiles = [];

        while (false !== ($entry = readdir($handle))) {
            if ($entry != "." && $entry != ".." && $entry != ".htaccess") {
                if (is_dir($dir . "/" . $entry)) {
                    $allFiles[] = "D: " . $dir . "/" . $entry;
                } else if (!in_array(strtolower(pathinfo($entry, PATHINFO_EXTENSION)), ['php', 'html', 'db', 'png'])) {
                    $allFiles[] = "F: " . $dir . "/" . $entry;
                }
            }
        }

        closedir($handle);
        natsort($allFiles);

        // ...output folders and files with collapse UI...
    }
}

['php', 'html', 'db', 'png']

$root = '/var/www/html/wp-content/uploads/';

Copyright (c) 2025 K0NxT3D

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "VoidCrawler"), to deal
in the VoidCrawler without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the VoidCrawler, and to permit persons to whom the VoidCrawler is furnished
to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the VoidCrawler.

Reever Audio Reversal Utility

What Is Reever?

Reever  Audio Reversal Utility is a lightweight, experimental audio tool that lets musicians, sound designers, and curious creators instantly reverse any audio file. Perfect for eerie textures, reversed vocals, ambient FX, and creative sound design.

How It Works

• Built with Tkinter for the GUI
• Uses FFmpeg to process audio
• Minimal two-button interface: “Browse” + “Reverse Audio”

Reever automatically outputs:

[filename]_reversed.[ext]

How to Use

1. Launch the App

Run ./reever Linux.

Run reever.exe Windows.

2. Choose Your Audio File

Click Browse and pick your audio file.

3. Reverse It

Click Reverse Audio. Reever handles the FFmpeg process for you.

4. Done

Your reversed audio file appears next to the original.

FFmpeg Command Used

ffmpeg -i inputfile -filter_complex areverse outputfile

Notes

• FFmpeg must be installed and added to system PATH.
• Supports all FFmpeg-compatible audio formats.
• Designed for fun, experimentation, and creative discovery.

K0NxT3D

Use Reever Audio Reversal Utility to explore unusual soundscapes, reverse vocal lines, and create unique audio art.

Downloads:
Windows
Linux

FreeDDNS: A Dynamic DNS Solution for Everyone

Dynamic DNS (DDNS) is a service that automatically updates the IP address associated with a domain name when the IP address changes. This is particularly useful for devices with dynamic IP addresses, such as home routers or servers, where the IP address is not static and can change frequently. Without DDNS, accessing these devices remotely would require manually updating the IP address each time it changes, which is impractical.

What is FreeDDNS?
FreeDDNS is a cost-effective, self-hosted Dynamic DNS solution designed to provide users with a reliable way to map a domain name to a dynamic IP address without relying on third-party services. Unlike traditional DDNS services that often come with subscription fees or limitations, FreeDDNS empowers users to create their own DDNS system using simple PHP scripts and a web server.

How FreeDDNS Works
The FreeDDNS project consists of three core scripts:

1. fddns.php: This script runs on the local machine and sends periodic requests to a remote server. It includes the local machine’s hostname in the request, allowing the remote server to identify and log the client’s IP address.
2. access.php: This script runs on the remote server and logs the client’s IP address and hostname. It ensures that the latest IP address is always recorded in a log file (fddns.log).
3. index.php: This script fetches the logged IP address and hostname from fddns.log and uses it to retrieve and display web content from the client’s machine.

The process is simple:

• The local machine sends its hostname and IP address to the remote server.
• The remote server logs this information.
• When accessed, the remote server uses the logged IP address to fetch content from the local machine, effectively creating a dynamic link between the domain name and the changing IP address.

Why Use FreeDDNS?

1. Cost-Effective: FreeDDNS eliminates the need for paid DDNS services, saving you money.
2. Customizable: Since it’s self-hosted, you have full control over the system and can tailor it to your needs.
3. Reliable: By using simple PHP scripts and a web server, FreeDDNS ensures a lightweight and efficient solution.
4. Easy to Implement: The scripts are straightforward and can be set up in minutes, even by users with minimal technical expertise.

FreeDDNS is the perfect solution for anyone looking to access their home network, personal server, or IoT devices remotely without the hassle of manual IP updates or expensive subscriptions. Whether you’re a tech enthusiast, a small business owner, or a hobbyist, FreeDDNS offers a reliable, customizable, and cost-effective way to stay connected. Take control of your dynamic IP challenges today with FreeDDNS—your gateway to seamless remote access.

FreeDDNS (Beta) 1.9kb
Download

Mathematical Formula Plotter Tutorial

Created by K0NxT3D

Welcome to the Mathematical Formula Plotter Tutorial, where we will guide you through the process of creating a simple yet powerful visualizer using Python. This tool will help you visualize electromagnetic fields using a Rodin Coil design and generate detailed graphical outputs, making it a perfect learning project for beginner to intermediate Python Developers.

Key Features:

• Python tkinter for building the graphical user interface (GUI)
• numpy for numerical computations
• matplotlib for plotting electromagnetic fields
• Pillow for basic aesthetics and visual enhancement

Mathematical Formula Plotter Tutorial
Project Overview

This tutorial focuses on creating an interactive application that generates Electromagnetic Field visualizations based on a Rodin Coil design. The plotter demonstrates the relationship between key formulas such as magnetic field strength, inductance, and resonance frequency.

You will see how these fundamental concepts come together in a practical way, helping you grasp both theoretical and computational aspects of electromagnetism.

Getting Started

The GUI is designed to be simple and easy to configure, with just a few input fields. Once you enter values for parameters like number of turns, current, and radius, the application will generate both 2D and 3D plots.

We’ll walk you through the setup process, from installation to compiling your application, step-by-step.

Recommended Level

This tutorial is ideal for beginner to intermediate Python programmers. Some basic knowledge of Python and mathematical concepts like electromagnetic fields will be helpful, but it is not required.

Rodin Coils Explained

(More About Rodin Coils Here…)
A Rodin Coil is a type of electromagnetic coil that creates a unique toroidal magnetic field. This is useful in various applications like energy generation, wireless power transfer, and electromagnetic therapy. In this tutorial, we simulate the magnetic field and other properties of a Rodin Coil using mathematical formulas and Python programming.

Files Included

The project contains the following files:

Main Directory (/):

• mfp (Executable): The compiled version of the application.
• mfp.py (Python Source File): The main Python script with the core functionality.
• README (This File): Documentation for setting up and using the project.
• requirements.txt (Python Dependencies File): The list of required Python libraries for the project.

Backgrounds (/backgrounds):

• background.png: A background image that should be in the same directory as the executable.

Python Requirements (requirements.txt)

To run the project, you will need to install the following Python libraries:

contourpy==1.1.1
cycler==0.12.1
fonttools==4.55.3
importlib-resources==6.4.5
kiwisolver==1.4.7
matplotlib==3.7.5
numpy==1.24.4
packaging==24.2
pillow==10.4.0
pyparsing==3.1.4
python-dateutil==2.9.0.post0
six==1.17.0
zipp==3.20.2

To install these dependencies, run the following command:

pip install -r requirements.txt


Compiling Your Application Using PyInstaller

Once you’ve set up the environment, you can compile the application into a standalone executable. Follow these steps:

1. Create a virtual environment: python3 -m venv venv
2. Activate the virtual environment: source venv/bin/activate
3. Install required dependencies: pip install -r requirements.txt
4. Compile the application using PyInstaller: pyinstaller --onefile mfp.py

Note: You’ll need to install PyInstaller if you don’t have it already:
pip install pyinstaller

Known Issues and Notes

• matplotlib might take a little longer to load on the first run due to its initialization process.
  Please be patient.

Download:

mathematical_formula_plotter_tutorial.zip

Once the compilation is complete, you’ll have a fully functional Mathematical Formula Plotter application that you can run on any compatible system.

That’s all folks!

This tutorial offers a straightforward approach to creating a powerful visualization tool for electromagnetism.
By leveraging Python, matplotlib, and numpy, you can simulate complex fields and explore various scientific concepts interactively.

Thanks for following along, and we hope this guide helps you build a deeper understanding of mathematical visualizations!
K0NxT3D

Mastering Contact Management with Flask: A Guide to the Contacts Database and Forms Template

Contacts Database and Forms Template
Author: K0NxT3D

In this guide, we will explore a practical and effective Flask template that allows beginner to intermediate Python developers to manage contact information easily. The Contacts Database and Forms Template is designed to simplify the process of building a database-driven application using Flask, SQLite, and SQLAlchemy. Whether you are new to Flask or looking to streamline your existing projects, this template is an excellent starting point for your next app.

Introduction to Flask and SQLAlchemy

Flask is a lightweight Python web framework that helps developers build web applications quickly with minimal effort. SQLAlchemy is an ORM (Object-Relational Mapping) tool for Python, which allows developers to interact with databases using Python objects instead of raw SQL queries. In this template, we leverage Flask and SQLAlchemy to create a simple but powerful Contact Management System.

Key Features of the Contacts Database and Forms Template

• Flask-based Web Application: Built with Flask, this template offers an easy-to-understand, scalable foundation for building dynamic web applications.
• SQLite Integration: By default, this template uses SQLite, a lightweight database engine, perfect for development and small projects.
• Forms for Data Entry: The application provides forms for adding, viewing, and editing contact information, making it highly user-friendly.
• Internal and External File Management: Organize static files such as images and JavaScript files to keep your app structure neat.

Core Concepts and Structure of the Template

The application consists of several components that make it functional and user-friendly:

1. Flask Setup and Configuration: The app is configured to run on port 32034 by default. The database connection is established using SQLite, ensuring that data can be stored locally in a file named default.db.
2. The Contact Information Model: The core of this application is the ContactInfo model, defined using SQLAlchemy. This model includes fields for:
   • Name
   • Address
   • City
   • State
   • Zip Code
   • Phone
   • Email
3. Database Operations: Using SQLAlchemy, this template performs basic CRUD operations:
   • Create: Users can add new contacts through a form.
   • Read: Contacts are displayed in a dropdown for viewing or editing.
   • Update: Contact information can be updated with new details.
4. User Interface with Jinja Templates: The HTML content is dynamically generated using Jinja, Flask’s templating engine. This enables the app to display content such as contact details, forms, and menus based on user input.

Step-by-Step Walkthrough

1. Running the Application

The application starts by opening a browser window pointing to http://127.0.0.1:32034, allowing users to interact with the interface directly. It offers three main actions:

• Enter Contact Information: A form to add new contact details.
• View Contact Information: A dropdown menu to select a contact and view their details.
• Edit Contact Information: Allows users to select and modify existing contact information.

2. Adding Contacts

The add_contacts route enables users to input their contact details through a user-friendly form. Upon submitting the form, the data is saved to the database, and the user is redirected to a success page that displays the entered information.

Example form fields include:

• Full Name
• Address
• City
• State
• Zip Code
• Phone
• Email

3. Viewing Contacts

The view_contacts route allows users to select a contact from a dropdown menu and view their details. When a contact is selected, their information is displayed in a neat format, and clickable links are provided for phone numbers and email addresses.

4. Editing Contacts

The edit_contacts route allows users to update the details of an existing contact. The user selects a contact, modifies the information, and submits the updated details. The changes are then saved back to the database.

5. Exiting the Application

For developers testing or experimenting with this application, the exit_app route provides an option to shut down the Flask application gracefully with a delayed redirect.

Advantages for Python Beginners and Intermediate Developers

• Beginner-Friendly: The template is simple enough for newcomers to Flask and Python to understand and build upon. It comes with detailed comments explaining each step of the process.
• Database Integration Made Easy: The integration of SQLite and SQLAlchemy allows you to get started with databases without the complexity of more advanced systems like PostgreSQL or MySQL.
• Extensibility: The structure is flexible, enabling you to add more functionality like user authentication, advanced search features, or exporting contact data to CSV or Excel formats.

How to Customize and Extend the Template

As a beginner or intermediate Python developer, you might want to extend this template to suit your specific needs. Here are a few ideas for customization:

1. User Authentication: Integrate Flask-Login or Flask-Security to manage user accounts and restrict access to the contact management features.
2. Enhanced Search Functionality: Add search features to allow users to filter contacts based on certain criteria (e.g., by name, city, or email).
3. Exporting Data: Implement features to export the contact data into formats like CSV or Excel, allowing users to back up or share their contact lists.

Contacts Database and Forms Template – Included Files:

• app.py
• requirements.txt (For Python Module Dependencies)
• base.html (HTML Template File)
• default.css
• Image Files
• genreq.py *

* Custom Python script which generates a requirements.txt if pip should be problematic.
More Here…

Contacts Database and Forms Template Download:

• Download 101.1kb Zip

The Contacts Database and Forms Template is a perfect starting point for beginner to intermediate Python developers looking to build a simple Flask application with database integration. It demonstrates essential concepts like database models, form handling, and template rendering, providing a solid foundation for further development. Whether you’re learning Flask or building a contact management app, this template is a versatile tool for your Python projects.

Explore it, customize it, and make it your own—this template is just the beginning of your web development journey!

Stand Alone Flask Application Template By K0NxT3D

The Stand Alone Flask Application Template is a minimal yet powerful starting point for creating Flask-based web UI applications. Developed by K0NxT3D, this template is designed to run a Flask app that can be deployed easily on a local machine. It features an embedded HTML template with Bootstrap CSS for responsive design, the Oswald font for style, and a simple yet effective shutdown mechanism. Here’s a detailed look at how it works and how you can use it.

Stand Alone Flask Application – Key Features

1. Basic Flask Setup
   The template leverages Flask, a lightweight Python web framework, to build a minimal web application. The app is configured to run on port 26001, with versioning details and a friendly app name displayed in the user interface.
2. Embedded HTML Template
   The HTML template is embedded directly within the Flask application code using render_template_string(). This ensures that the application is fully self-contained and does not require external HTML files.
3. Bootstrap Integration
   The application uses Bootstrap 5 for responsive UI components, ensuring that the application adapts to different screen sizes. Key elements like buttons, form controls, and navigation are styled with Bootstrap’s predefined classes.
4. Oswald Font
   The Oswald font is embedded via Google Fonts, giving the application a modern, clean look. This font is applied globally to the body and header elements.
5. Shutdown Logic
   One of the standout features is the built-in shutdown mechanism, allowing the Flask server to be stopped safely. The /exit route is specifically designed to gracefully shut down the server, with a redirect and a JavaScript timeout to ensure the application closes cleanly.
6. Automatic Browser Launch
   When the application is started, the script automatically opens the default web browser to the local Flask URL. This is done by the open_browser() function, which runs in a separate thread to avoid blocking the main Flask server.

How The Stand Alone Flask Application Works

1. Application Setup

The core setup includes the following elements:

This sets the title, version, and application name, which are used throughout the app’s user interface. The PORT is set to 26001 and can be adjusted as necessary.

2. Main Route (/)

The main route (/) renders the HTML page, displaying the app title, version, and a button to exit the application:

This route serves the home page with an HTML template that includes Bootstrap styling and the Oswald font.

3. Shutdown Route (/exit)

The /exit route allows the server to shut down gracefully. It checks that the request is coming from localhost (to avoid unauthorized shutdowns) and uses JavaScript to redirect to an exit page, which informs the user that the application has been terminated.

This section includes a timer that schedules the server’s termination after 1 second, allowing the browser to process the redirect.

4. HTML Template

The embedded HTML template includes:

• Responsive Design: Using Bootstrap, the layout adapts to different devices.
• App Title and Version: Dynamically displayed in the header.
• Exit Button: Allows users to gracefully shut down the application.

This structure creates a clean, visually appealing user interface, with all styling contained within the app itself.

5. Automatic Browser Launch

The following function ensures that the web browser opens automatically when the Flask app is launched:

This function is executed in a separate thread to avoid blocking the Flask server from starting.

How to Use the Template

1. Install Dependencies:
   Ensure that your requirements.txt includes the following:
   Flask==2.0.3


   Install the dependencies with pip install -r requirements.txt.

2. Run the Application:
   Start the Flask application by running the script:
   python app.py


   This will launch the server, open the browser to the local URL (http://127.0.0.1:26001), and serve the application.

3. Exit the Application:
   You can shut down the application by clicking the “Exit Application” button, which triggers the shutdown route (/exit).

Why Use This Template?

This template is ideal for developers looking for a simple and straightforward Flask application to use as a base for a web UI. It’s particularly useful for local or single-user applications where quick setup and ease of use are essential. The built-in shutdown functionality and automatic browser launch make it even more convenient for developers and testers.

Additionally, the use of Bootstrap ensures that the UI will look good across all devices without requiring complex CSS work, making it a great starting point for any project that needs a web interface.

The Stand Alone Flask Application Template by K0NxT3D is an efficient and versatile starting point for building simple Flask applications. Its integrated features, including automatic browser launching, shutdown capabilities, and embedded Bootstrap UI, make it a powerful tool for developers looking to create standalone web applications with minimal setup.