DEV Community: robert19066

Transforming Web Apps to Android Using a Single Command!

robert19066 — Thu, 12 Mar 2026 19:46:07 +0000

So everyone knows how HARD is to port your web app to Android... I had this struggle too. Honestly, I was making my own whiteboard software, yet it had to run on Android, and it took many days to tweak WebView so it worked.

So what we do?

Simple: Make a tool for this. So i present to you my tool - Bonboneka. What it does? Well, duh, it's a build tool to transform your (vanilla) web app into an WebView-compatible Android app, using a single command - bomk create <dir with files>. More info is on the repository's README. Ill post sneaky peeks of the next versions.

How I changed C++ forever

robert19066 — Wed, 15 Oct 2025 16:00:42 +0000

So I recently started coding in C++,and I realized its bad. Like horrible. Atrocious. But I said to myself: "I can make it good..." so I invented H Suite, my own collection of C++ header files, that add to C++ I/O improvements, CLI Power-ups, a lot of new types(yes we have Vertex for you OpenGL fans!) and EVEN AI! AI? IN C++?! YES!
And yeah if you wanna check it out its avabile on Github

robert19066 / H-Suite-C-

An suite of many usefull c++ header files.

HSuite

Guys thank you so much we reached 100 views and 50 pulls! 🥳

v4 Status: Working on new features. please ignore the cmake stuff its only for testing purposes.

A comprehensive C++ utility library providing elegant solutions for common programming tasks, from fancy terminal output to LLM integration.

📦 Installation

Download the repository as a ZIP file or get the latest version from the Releases tab
Extract the hsuite folder to your project directory

Include the headers you need in your C++ files:

#include "hsuite/fancyprint.h"
#include "hsuite/cllama.h"
#include "hsuite/stb.h"
#include "hsuite/typesuite.h"

🎯 Features

FancyPrint

Beautiful terminal output with ANSI colors and interactive elements:

Colored logging (info, warning, error, success)
User input prompts
Selection menus
Confirmation dialogs
Loading animations
Countdown timers
ASCII graphs
Math expression display

FancyPrint::Print_info("Starting application...")
FancyPrint::Print_success("Operation completed!

…

View on GitHub

Inflate - Next level compression,straight from the terminal!

robert19066 — Thu, 04 Sep 2025 09:16:44 +0000

Inflate is a Python-based compression and archival utility that supports two compression methods:

ACS (Abstract Compression System): Local compression using 7z format with .acs extension.
CBAC (Cloud-Based Abstract Compression): Cloud-enabled compression using Dawnbond(Supabase abstraction layer made by me) for remote storage

The system creates file maps and content files, compresses them using py7zr (7-Zip), and optionally uploads to cloud storage with retrieval codes.

Inner works

How ACS Works

ACS(or Abstract Compression System) generates 2 blueprints of the selected folder: filemap.txt(map of all files) and filecntt.txt(file contents). Then the 2 files get packed into an .acs arhive. ACS is 3% faster than ZIP and 53% smaller than ZIP(tested on the latest CURL build)

How CBAC Works

CBAC(or Cloud Based Abstract Compression) uses ACS to create an arhive,and then it stores it using Dawnbond,an supabase abstraction.You can purge,upload and take down from CBAC.

Core Components

inflate.py: Main CLI interface and orchestration layer
acsmain.py: ACS compression/decompression engine with 7z handling
dawnbond.py: Supabase cloud storage interface (DawnbondCloud class)

Data Flow

Compression: Files → filemap.txt + filecntt.txt → 7z archive → .acs file → (optional) cloud upload
Decompression: .acs/.cbac file → extract 7z → parse filemap/filecntt → reconstruct directory structure

GNU openVBS - VBScript,Reborn

robert19066 — Thu, 04 Sep 2025 09:07:42 +0000

GNU OpenVBS Framework 🚀

A powerful Python toolkit for generating and executing VBScript (.vbs) files with ease.

OpenVBS bridges the gap between Python's simplicity and VBScript's Windows automation capabilities, allowing you to create sophisticated Windows automation scripts using intuitive Python functions and an intuitive CLI.

NOTE: The examples may be outdated,or broken due to frequevent updates and continuosly-changing ecosystem!

✨ Features

🔧 Core Language Features

Variables, constants, and arrays
Control flow (if/else, loops, select/case)
Functions and subroutines
Error handling and debugging
Object creation and manipulation

📁 File System Operations

File and folder management
Text file reading/writing
Directory traversal and organization
Path manipulation utilities

🌐 Windows Integration

Registry operations (read/write)
Environment variables
Shell command execution
Windows Management Instrumentation (WMI)
System information gathering

📊 Data Processing

String manipulation and formatting
Mathematical operations
Date/time functions
Array and collection handling

🌐 Network & Communication

HTTP GET/POST requests
File downloading
Email sending (via CDO)
Web service interactions

🎛️ User Interface

Message boxes and input dialogs
File/folder picker dialogs
System notifications
Custom dialog creation

📦 Advanced Features

Module system for code reuse
Configuration management
Performance profiling
Diacnostics
Plugins!

🚀 Quick Start

Installation

# Clone the repository
git clone https://github.com/yourusername/openvbs.git
cd openvbs

# Install dependencies (optional)
pip install colorama  # For enhanced CLI colors

Basic Example

from openvbs import *

# Clear any previous script
clear_vbs()

# Create variables
define_variable("username", "John Doe")
define_variable("age", 25)

# Show a message
message_prompt(f"Hello {username}!", title="Welcome")

# Create a simple loop
for_loop("i", 1, 5, 1, 'WScript.Echo "Count: " & i')

# Execute the generated VBScript
execute_vbs()

File Operations Example

from openvbs import *

clear_vbs()

# Create a log file
create_file("system.log", "System started at: ")
write_file("system.log", current_datetime(), append=True)

# Read system information
get_system_info()

# Organize files by extension
template_file_organizer()

execute_vbs()

Windows Automation Example

from openvbs import *

clear_vbs()

# Read from registry
registry_read("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion", "ProductName")

# Get environment variables
define_variable("user_profile", "")
user_profile = get_env_var("USERPROFILE")

# Run a system command
shell_execute("notepad.exe", wait_on_return=False)

execute_vbs()

📚 Documentation

Core Functions

Variables and Constants

define_variable("name", "value")        # Create a variable
const_variable("PI", 3.14159)          # Create a constant
define_array("numbers", [1, 2, 3, 4])  # Create an array

Control Flow

# Conditional statements
if_else("x > 10", "WScript.Echo 'Large'", "WScript.Echo 'Small'")

# Loops
for_loop("i", 1, 10, 1, "WScript.Echo i")
do_while("x < 100", "x = x + 1")

# Select case
select_case("userChoice", {
    1: "WScript.Echo 'Option 1'",
    2: "WScript.Echo 'Option 2'",
    "default": "WScript.Echo 'Invalid choice'"
})

File Operations

file_system_object()                    # Initialize file system
create_file("data.txt", "Hello World")  # Create file with content
read_file("data.txt")                   # Read file content
write_file("log.txt", "Entry", True)    # Write/append to file
delete_file("temp.txt")                 # Delete file
folder_exists("C:\\MyFolder")           # Check folder existence

Windows Integration

# Registry operations
registry_read("HKCU\\Software\\MyApp", "Setting1")
registry_write("HKCU\\Software\\MyApp", "Setting1", "NewValue")

# Environment variables
get_env_var("USERNAME")
set_env_var("MY_VAR", "MyValue")

# Shell commands
shell_execute("dir", window_style=1, wait_on_return=True)
run_program("C:\\Program Files\\MyApp\\app.exe", "/silent")

Network Operations

# HTTP requests
http_get("https://api.example.com/data")
http_post("https://api.example.com/submit", "data=value")
download_file("https://example.com/file.zip", "C:\\Downloads\\file.zip")

# Email
send_email("user@example.com", "Subject", "Message body", "smtp.server.com")

🛠️ Advanced Features

Module System

# Export current script as a module
export("my_utilities.vbs")

# Import a module into current script
get("my_utilities.vbs")

# Clear all saved modules
clear_modules()

Configuration Management

# Save settings
set_setting("default_path", "C:\\MyApp")
set_setting("auto_backup", True)

# Load settings
path = get_setting("default_path", "C:\\Default")
backup_enabled = get_setting("auto_backup", False)

Debugging and Profiling

# Debug output
debug_print("Variable x = " + str(x))

# Log to file
log_to_file("Process started", "app.log")

# Performance timing
start_timer("processing")
# ... your code here ...
end_timer("processing")

# Assertions
assert_condition("x > 0", "X must be positive")

Error Handling

# Try-catch style error handling
error_handling(
    try_block="risky_operation()",
    catch_block="WScript.Echo 'Operation failed: ' & Err.Description"
)

# Traditional VBS error handling
on_error_resume_next()
# ... code that might fail ...
on_error_goto_zero()

Plugins!

To use use plugins folow these steps:

Take your plugin file and paste it to files/plugins(or inside PMN, run the command plugin install ).
Run cli.bat.
Run plugin load.
Run plugin list(for seeing your plugins).
Run plugin include.

📁 Project Structure

openvbs/
├── openvbs/
│   ├── __init__.py          # Main imports and exports
│   ├── main.py              # Core functions and language features
│   ├── runner.py            # VBScript execution engine
├── files/
│   ├── windows/
│   │   └── output.vbs       # Generated VBScript output
│   ├── compiled_output/     # Packaged executables
│   ├── modules/             # Saved script modules
├── src/
│   └── examples/            # Example scripts
├── tests/                   # Unit tests
└── LICENSE                  # License file

🎯 Use Cases

System Administration

Automated system monitoring and reporting
User account management
Software deployment and configuration
Registry maintenance and cleanup

File Management

Bulk file operations and organization
Automated backups and synchronization
Log file processing and analysis
Data migration and conversion

Network Operations

Automated data collection from web services
Batch downloading and processing
Email automation and notifications
System health monitoring

Windows Automation

Application control and automation
Scheduled task creation and management
System configuration deployment
Performance monitoring and alerting

🚨 Requirements

Windows Operating System (Windows 7/10/11)
Python 3.6+
Windows Script Host (pre-installed on Windows)
IExpress (for .exe packaging, included with Windows)

Optional Dependencies

pip install colorama  # Enhanced terminal colors

🤝 Contributing

Contributions are welcome! Here's how to get started:

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes and add tests
Commit your changes: git commit -m 'Add amazing feature'
Push to the branch: git push origin feature/amazing-feature
Open a Pull Request

Development Setup

# Clone your fork
git clone https://github.com/yourusername/openvbs.git
cd openvbs

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install development dependencies
pip install -r requirements-dev.txt

# Run tests
python -m pytest tests/

📋 Examples

Example 1: System Information Script

from openvbs import *

clear_vbs()
comment("System Information Gatherer")

# Get computer name
get_env_var("COMPUTERNAME")
define_variable("computer_name", get_env_var("COMPUTERNAME"))

# Get OS information
get_os_info()

# Get system specs
get_system_info()

# Save to file
write_file("system_info.txt", "System Report Generated: ")
write_file("system_info.txt", current_datetime(), append=True)

execute_vbs()

Example 2: File Backup Script

from openvbs import *

clear_vbs()
comment("Automated Backup Script")

# Define source and destination
define_variable("source_folder", "C:\\Important Files")
define_variable("backup_folder", "D:\\Backups")

# Create backup folder with timestamp
define_variable("timestamp", "")
current_datetime()
# Format: YYYY-MM-DD_HH-MM-SS
string_replace(current_datetime(), "/", "-")
string_replace(current_datetime(), ":", "-")
string_replace(current_datetime(), " ", "_")

# Copy files
shell_execute('xcopy "' + source_folder + '" "' + backup_folder + '\\Backup_' + timestamp + '\\" /E /I /Y')

message_prompt("Backup completed successfully!", title="Backup Status")

execute_vbs()

Example 3: Network Monitor

from openvbs import *

clear_vbs()
comment("Network Connectivity Monitor")

# Test multiple servers
servers = ["google.com", "github.com", "stackoverflow.com"]

for server in servers:
    define_variable(f"result_{server.replace('.', '_')}", "")
    shell_execute(f'ping -n 1 {server} > nul')

    if_else(
        "Err.Number = 0",
        f'WScript.Echo "{server}: Online"',
        f'WScript.Echo "{server}: Offline"'
    )

# Log results
log_to_file("Network check completed", "network_monitor.log")

execute_vbs()

🐛 Troubleshooting

Common Issues

Q: "cscript.exe not found" error

A: Ensure you're running on Windows with Windows Script Host installed. Try running cscript in Command Prompt to verify.

Q: VBScript execution fails with syntax error

A: Check the generated output.vbs file for syntax issues. Use debug_print() to trace execution.

Q: File permission errors

A: Run your Python script as Administrator, or ensure the target directories are writable.

📜 License

This project is licensed under the GNU GENERAL PUBLIC LICENSE V3 - see the LICENSE file for details.

🏆 Acknowledgments

Inspired by the need for simpler Windows automation
Built for system administrators, developers, and automation enthusiasts
Thanks to the Python and VBScript communities for inspiration

🔮 Roadmap

Upcoming Features

[ ] GUI Builder: Visual interface for creating VBScript GUIs
[ ] PowerShell Integration: Hybrid PowerShell/VBScript generation
[ ] Active Directory Integration: User and computer management functions
[ ] Database Connectivity: SQL Server and Access database operations
[ ] Excel Automation: Advanced Excel manipulation capabilities
[ ] Service Management: Windows service creation and management
[ ] Event Log Integration: Reading and writing Windows event logs
[ ] Scheduled Task API: Advanced task scheduler integration

Version History

v2.0 Patch - Removed packaging due to high risk of system instability and sudden reboots
v2.0 - Major rewrite with enhanced CLI, templates, and packaging
v1.0 - Initial release with basic VBScript generation

Pack, the new-gen workflow manager

robert19066 — Thu, 21 Aug 2025 13:02:50 +0000

Project Pack V1, or simply Pack, is a Python-based "packlet" (workflow) manager that allows users to create, store, and execute custom shell command sequences with various execution modes and privilege configurations. The project provides both a CLI interface for creating packlets and an execution engine for running them.

Dev note: Trust me, it's really awsome!

Core Architecture

The codebase is organized around four main components:

Main Components

mainShell.py: The user-facing CLI application with a rich terminal interface including colored banners, menus, loading bars, and wizards for packlet creation and execution
mainCompile.py: The core execution engine (Main class) that parses packlet files and executes shell commands with different execution strategies
helper_functions.py: Parser utilities (HelperFunctions class) for extracting configuration from packlet files
createFile.py: File creation utility for generating new packlet files with proper formatting

Packlet File Format

Packlets are custom configuration files with specific extensions and structure:

.paklt: Standard packlets (default execution mode - stops on errors)
.fopak: Bulldozer packlets (continues execution despite errors)

Packlet file structure:

$type=<shell>          # Shell to use (bash, zsh, fish, etc.)
$excmeth:<method>      # Execution method (default/bulldozer)
$isudo=<true/false>    # Whether sudo privileges are required

<command1>
<command2>
...
---

Execution Modes

Default Mode: Stops execution immediately when any command fails
Bulldozer Mode: Continues executing all commands even when some fail, providing a summary of failed commands at the end

Common Development Tasks

Running the Application

python mainShell.py

Testing Packlet Execution

# Create a simple test packlet
echo -e '$type=bash\n$excmeth:default\n$isudo=false\n\necho "Hello World"\nls -la\n---' > test.paklt

# Test execution programmatically
python -c "
from mainCompile import Main
main = Main('test.paklt')
results = main.run(['test.paklt'])
print(results)
"

Creating Packlets Programmatically

python -c "
import createFile
createFile.create_packlet_file('default', 'bash', False, ['echo \"test\"', 'pwd'], 'example.paklt')
"

File Structure

/
├── mainShell.py          # Main CLI application with UI
├── mainCompile.py        # Core execution engine
├── helper_functions.py   # Packlet file parsers
├── createFile.py         # File creation utilities
├── packlets/             # Directory for storing packlets (created automatically)
└── __pycache__/          # Python bytecode cache

Development Notes

Error Handling

The codebase implements two distinct error handling strategies:

Default execution: Uses subprocess.run() with check=True to raise exceptions on command failure
Bulldozer execution: Uses subprocess.run() with check=False and manually tracks failed commands

UI Framework

The CLI uses ANSI color codes extensively through the Colors class for terminal styling. Key UI components include:

Dynamic menu boxes with perfect alignment
Progress indicators (loading bars and spinners)
Step-by-step wizards for packlet creation
Colored success/error/warning messages

Dependencies

pyparsing: Used in helper_functions.py (imported but not actively used in current implementation)
subprocess: Core dependency for shell command execution
os: For file system operations and screen clearing
sys: For application exit handling
time: For UI animations and delays
random: For randomized loading animations

Packlet Storage

All created packlets are stored in the packlets/ directory, which is automatically created if it doesn't exist. The directory structure is flat with no subdirectories.

Security Considerations

Sudo execution is configurable per packlet via the $isudo parameter
Commands are executed through shell subprocess calls, so standard shell injection precautions apply
Bulldozer mode can potentially mask security-relevant command failures

Marker IDE, next gen ai-powered IDE!

robert19066 — Mon, 23 Jun 2025 17:54:01 +0000

Hiiiii,i made this cool editor like 1 month ago and it goes like wild.
Go check it out!
Any fork is accepted.
SPREAD THE WORD
XD