DEV Community: Hao Nguyen

InitOps: One-Command WordPress Deployment on Ubuntu

Hao Nguyen — Wed, 07 Oct 2026 06:13:26 +0000

Setting up a production-ready WordPress server on a fresh VPS often means going through a long list of tasks: installing Nginx, PHP-FPM, MariaDB, Redis, configuring firewall rules, setting up Fail2Ban, tuning PHP and database settings, enabling SSL, and preparing backups.

InitOps is designed to simplify that entire process.

InitOps is a single-file interactive Python CLI that can turn a fresh Ubuntu server into a production-ready WordPress host with a single command and a few configuration choices. It focuses on Ubuntu LTS servers and is designed to work across VPS sizes ranging from small 1 GB instances to larger dedicated servers.

What is InitOps?

InitOps provides a complete LEMP-based WordPress environment without requiring Docker, Ansible, or a large collection of shell scripts.

The stack includes:

Nginx
MariaDB
PHP-FPM
Redis
WordPress
iptables / nftables-based firewall configuration
Fail2Ban

It also takes care of several common tasks that normally have to be configured manually, including performance tuning, backups, SSL renewal, domain migration, and server monitoring.

Ubuntu 24.04 and Ubuntu 26.04 Support

InitOps v2.0.0 supports Ubuntu 24.04 LTS and Ubuntu 26.04 LTS.

On Ubuntu 24.04, InitOps supports PHP 8.3, 8.4, and 8.5. On Ubuntu 26.04, PHP 8.5 is selected automatically and is installed from Ubuntu's official repositories without requiring a PPA. MariaDB and Redis versions are also adapted to the operating system version.
InitOps also performs OS detection and stops installation on unsupported operating systems instead of blindly applying system-level configurations.

Automatic Server Performance Tuning

One of the more interesting parts of InitOps is its hardware-aware configuration.

The tool detects the server's RAM and CPU resources and selects one of six optimization profiles:

micro
small
standard
medium
large
xlarge

Each profile adjusts important components such as Nginx, PHP-FPM, MariaDB, Redis, and OPcache instead of using exactly the same configuration for every VPS.

For example, PHP-FPM worker sizing is calculated based on the RAM remaining after accounting for MariaDB, Redis, and system overhead. OPcache is also configured according to the selected hardware profile.

This is particularly useful for WordPress servers running on smaller VPS instances, where allocating too much memory to a single service can quickly become a problem.

PHP Version Manager

InitOps is not limited to selecting a PHP version during the initial deployment.

After deployment, the built-in PHP Version Manager can install additional PHP branches and switch between them without rebuilding the entire server. Old versions can remain installed so they can be restored when necessary.

The switching workflow is designed to reduce downtime. InitOps prepares the new PHP-FPM configuration, validates it, starts the new PHP-FPM service alongside the current one, updates the Nginx virtual hosts, validates Nginx, and only then retires the old PHP-FPM service.

For developers maintaining multiple WordPress projects, this can be much more convenient than manually rebuilding PHP-FPM configurations every time a site needs a different PHP branch.

Multi-Site WordPress Hosting

InitOps can also host multiple WordPress installations on a single VPS.

Each additional site gets its own database, Redis database index, Nginx virtual host, and web root. WP-Cron is also handled through the system cron with locking to avoid overlapping executions.

Adding another site is available directly from the interactive menu:

initops

Then choose:

[7] Add New Website

This keeps the deployment process consistent even when a single server is hosting several independent WordPress websites.

Security by Default

Security is another part of the default setup.

InitOps configures firewall rules, enables Fail2Ban for SSH brute-force protection, hardens MariaDB, and uses Unix sockets for MariaDB and Redis instead of exposing them over TCP. It also applies several WordPress hardening settings and standard file permissions.

For Ubuntu 24.04 and 26.04, InitOps uses different Fail2Ban backends according to the operating system, including iptables on 24.04 and nftables plus systemd journal on 26.04.

Backups, Monitoring, and SSL

InitOps includes several operational features that are easy to overlook when manually setting up a VPS.

Database backups use WP-CLI, automatically compress the resulting SQL dump with gzip, and remove backups older than 30 days. The backup system can also handle individual sites or all configured sites.

For monitoring, InitOps can send bilingual English/Vietnamese Discord alerts when disk space becomes critical, RAM usage is exhausted, CPU load becomes excessive, or MariaDB/MySQL goes down. It can also report service recovery events.

For SSL, InitOps supports Cloudflare DNS-01 renewal. It can configure the Certbot Cloudflare plugin, store credentials securely, configure the renewal workflow, reload Nginx after successful renewal, and perform a dry-run test before finishing.

Domain Migration

Changing a production domain can be surprisingly annoying because it involves more than just editing an Nginx configuration.

InitOps provides a one-shot domain migration workflow that updates the Nginx virtual host, issues a new SSL certificate, performs a database search-replace while respecting serialized WordPress data, flushes Redis, and automatically rolls back when Nginx validation fails.

Getting Started

On a fresh Ubuntu 24.04 or Ubuntu 26.04 LTS server, run:

curl -fsSL https://raw.githubusercontent.com/brokensmile2103/initops/main/install.sh | bash

There is also an installer endpoint provided by Init HTML:

curl -fsSL https://inithtml.com/initops/install.sh | bash

After installation, launch InitOps with:

initops

And update the engine with:

initops update

These are the documented quick-start commands for InitOps v2.0.0.

Final Thoughts

InitOps is aimed at a simple problem: making WordPress server deployment repeatable without turning every new VPS into a manual sysadmin project.

Instead of starting with a blank Ubuntu server and configuring every component individually, InitOps provides an opinionated stack with hardware-aware tuning, security defaults, multi-site support, PHP version management, backups, monitoring, and SSL automation.

For developers who regularly deploy WordPress on Ubuntu VPS servers, that can save a considerable amount of repetitive setup work.

InitOps is open source and released under the MIT License.

Note: InitOps modifies system-level configuration such as Nginx, MariaDB, Redis, firewall rules, and cron. The project recommends testing on a non-production server or keeping a backup before deployment.

→ Project Page
→ GitHub

Init Local Uploader: A Simple Self-Hosted Image Workflow for Developers

Hao Nguyen — Wed, 30 Sep 2026 08:11:48 +0000

Uploading an image is easy.

Managing hundreds of images, processing them safely, keeping their URLs predictable, and finding them again later is where things get messy.

Init Local Uploader is a small self-hosted PHP tool built around that exact problem. Instead of sending your images to a third-party service, it lets you keep the entire workflow on your own server.

The idea is simple:

Upload → Process → Store → Generate HTML/Markdown → Find it again later

Why would a developer need this?

For a personal blog, documentation site, or internal project, using a full image management platform can sometimes be unnecessary.

You may already have:

a VPS
PHP
local storage
a website serving the images

So why introduce another service just to upload a few screenshots?

Init Local Uploader turns your existing server into a small image utility.

You can drag and drop images, paste screenshots directly from the clipboard, resize them, optionally convert them to WebP, and immediately get ready-to-use HTML, Markdown, or URLs.

The useful part is how it handles failure

Image processing has more edge cases than it first appears.

Large images can run into PHP memory limits. Transparent images can lose their alpha channel. Animated GIFs can accidentally be flattened. Some images simply cannot be processed safely.

The uploader takes a conservative approach.

When processing cannot be done safely, the original image can be preserved instead of being silently lost. Animated GIF, WebP, and APNG files are also kept intact rather than being flattened.

That makes the tool more useful as a reliable upload workflow, rather than simply an "image optimizer".

Each image is handled independently

Multiple uploads are sent as individual requests.

That means one failed image does not have to ruin the entire queue. Each file has its own progress and result, with retry support for failures.

This is especially practical when uploading a large batch of screenshots or photos.

Your uploads are searchable

Another useful feature is the local SQLite-backed history.

Instead of wondering where an old screenshot went, you can search previous uploads by filename or ALT text, filter by folder, and copy the generated markup again.

For a developer maintaining documentation or a content-heavy website, this can save more time than the actual upload itself.

Self-hosting also means fewer moving parts

There is no external storage service, SDK, or API key required.

The application runs directly on your PHP server and stores the images and history locally.

That makes it a good fit for developers who prefer straightforward infrastructure:

Browser
   ↓
Your server
   ├── PHP application
   ├── SQLite history
   └── Uploaded images

You remain in control of the files and the URLs.

A small tool with a practical scope

Init Local Uploader is not trying to become a complete cloud media platform.

Its purpose is much narrower:

Give developers a simple, private place to upload images and immediately turn them into something usable.

For self-hosted blogs, documentation, portfolios, staging environments, or internal tools, that can be exactly enough.

The project also puts a fair amount of attention into the less visible parts of an uploader: file validation, CSRF protection, login rate limiting, safe deletion, filename normalization, and server-side handling of problematic images.

Final thoughts

Sometimes the simplest architecture is the one you already have.

When a server is already running PHP and has storage available, a lightweight self-hosted uploader can be a surprisingly practical alternative to adding another external service.

Init Local Uploader is essentially that idea packaged into a small, focused application.

For the complete feature list, configuration options, deployment notes, and latest changes, see the project page: https://en.inithtml.com/tools/init-local-uploader-a-simple-self-hosted-image-uploader-for-your-own-server/

Init Pulse For Discord – Fast, Minimal Discord Notifications for WordPress

Hao Nguyen — Tue, 29 Sep 2026 05:29:34 +0000

Init Pulse For Discord is a lightweight, backend-only Discord notification plugin for WordPress. It sends post publish and update notifications directly to Discord through webhooks — with rich embeds, role mentions, per-category/tag routing, and optional hot-post milestone alerts.

No external SDKs. No frontend JavaScript. No unnecessary database tables.

Just WordPress hooks, Discord webhooks, and a clean notification pipeline.

Why Init Pulse For Discord?

Keeping a Discord community informed about new WordPress content usually means connecting several systems together or relying on a large automation platform.

Init Pulse For Discord takes a much simpler approach.

Connect a Discord webhook, choose which post types to monitor, and WordPress can automatically notify your Discord server whenever tracked content is published or updated.

But it goes further than a basic "new post" webhook.

You can route specific categories and tags to their own Discord channels, mention specific Discord roles, customize webhook identities, send rich embeds, and trigger separate alerts when a post reaches a view milestone.

Everything runs server-side with no frontend assets and no external SDK dependencies.

It's part of the Init Plugin Suite — following the same minimalist, performance-first philosophy as the rest of the suite.

Features at a Glance

Automatic WordPress Notifications

Send notifications when content is published
Optionally notify Discord when content is updated
Select exactly which post types should trigger notifications
Works with standard posts, pages, products, and Custom Post Types
Markdown-ready message templates
Placeholder-based dynamic content

Supported placeholders include:

{title}
{title_url}
{url}
{excerpt}
{site_name}
{author}
{categories}
{tags}
{post_type}
{date}

This makes the plugin useful for blogs, news sites, editorial platforms, communities, WooCommerce stores, and custom WordPress applications.

Rich Discord Embeds

Notifications can be delivered as formatted Discord embeds containing:

Title
Description
Accent color
Footer
Timestamp
Optional featured image

Prefer something simpler?

You can switch to plain-text messages with the Rich Embed toggle.

Role-Aware Mentions

Assign Discord Role IDs directly to WordPress categories or tags.

When content matching those terms is published or updated, Init Pulse For Discord can include the configured role mention in the notification.

This is useful for communities where different Discord roles follow different topics.

For example:

WordPress category: Development
Discord role: <@&123456789012345678>

WordPress category: News
Discord role: <@&987654321098765432>

Your WordPress taxonomy becomes a simple routing and notification layer for Discord.

Per-Category / Tag Webhooks

Different types of content often belong in different Discord channels.

Init Pulse For Discord lets any Category or Tag have its own Discord Webhook URL.

For each term, you can configure:

Discord Webhook URL
Username override
Avatar override
"Only send to this webhook" behavior

By default, a matching post is delivered to both the term-specific webhook and the global webhook.

Enable Only send to this webhook to skip the global destination completely.

If a post belongs to multiple categories or tags with dedicated webhooks, the plugin sends to every unique destination while deduplicating repeated webhook URLs.

                WordPress Post
                      │
          ┌───────────┴───────────┐
          │                       │
     Category: Dev           Tag: WordPress
          │                       │
      Webhook A                Webhook B
          │                       │
          └───────────┬───────────┘
                      ↓
              Discord Channels

The same routing logic applies to publish/update notifications and Hot Post Milestones.

Hot Post Milestones

Connect Init View Count and turn view counts into Discord notifications.

For example:

1,000 views
5,000 views
10,000 views
50,000 views
100,000 views

When a tracked post crosses one of those thresholds, Discord receives a dedicated milestone notification.

Each milestone is sent once per post.

If a post jumps over several thresholds at once, only the highest milestone reached is sent.

Hot Post Milestones have their own message template with:

{views}
{views_short}
{milestone}

For example:

🎉 This post just reached {milestone} views!

Current views: {views_short}

The feature is completely optional. If Init View Count is not active, the setting simply remains dormant without affecting the rest of the plugin.

Install Init View Count later and the feature starts working automatically — no re-save required.

Delivery Troubleshooting

A lightweight Delivery Log keeps a rolling snapshot of recent webhook deliveries.

Each entry records whether a notification succeeded or failed.

When a post is routed to several destinations, each webhook gets its own delivery-log entry.

The log is stored lightly in wp_options with autoload = no, keeping it out of the normal frontend autoload path.

Built for Performance

Backend-only implementation
No frontend JavaScript
No frontend CSS
No external SDKs
No external Discord API client libraries
Lightweight WordPress options storage
Timeout and retry handling
Discord 429 Retry-After support
Safe-by-default hook integration

Core Modules

Module	What it does
Publish Notifications	Sends Discord alerts when tracked content is published
Update Notifications	Optionally notifies Discord when tracked content is updated
Custom Post Types	Choose exactly which post types trigger notifications
Rich Embeds	Send formatted Discord embeds with title, description, color, footer, timestamp, and image
Plain Text Mode	Send simple Markdown-ready text instead of an embed
Role Mentions	Map WordPress categories/tags to Discord Role IDs
Per-Term Webhooks	Route categories/tags to dedicated Discord destinations
Webhook Identity	Override Username and Avatar per destination
Global Webhook	Default Discord destination for notifications
Hot Post Milestones	Notify Discord when Init View Count thresholds are crossed
Delivery Log	Track recent success/error results per destination
Test Message	Verify a webhook directly from the settings screen
Retry Engine	Retry failed requests and respect Discord rate-limit responses

How It Works

The notification flow is intentionally simple.

WordPress content changes
        ↓
Post type is checked
        ↓
Publish / update context is resolved
        ↓
Categories and tags are inspected
        ↓
Role mentions are resolved
        ↓
Webhook destinations are resolved
        ↓
Duplicate webhook URLs are removed
        ↓
Discord payload is generated
        ↓
Webhook request is sent
        ↓
Delivery result is logged

For a normal publish/update notification:

WordPress fires the relevant content hook.
Init Pulse For Discord checks whether the post type is enabled.
The plugin builds the notification using the configured template.
Categories and tags are inspected for Discord Role IDs and dedicated webhooks.
Global and per-term destinations are resolved according to the routing rules.
Duplicate webhook URLs are deduplicated.
The final payload is sent to each destination.
Delivery results are recorded in the lightweight Delivery Log.

The Hot Post Milestones flow is similar, but uses view-count thresholds from Init View Count.

Post view count changes
        ↓
Milestone thresholds checked
        ↓
Already notified?
   ┌────┴────┐
   │         │
  YES        NO
   │         │
  Skip    Build alert
             ↓
      Resolve webhooks
             ↓
        Send to Discord
             ↓
       Mark milestone sent

No polling service or external scheduler is required for the normal notification flow.

Message Templates

The notification template is fully customizable.

Available placeholders:

Placeholder	Description
`{title}`	Post title
`{title_url}`	Post title with its URL
`{url}`	Post permalink
`{excerpt}`	Post excerpt
`{site_name}`	WordPress site name
`{author}`	Post author
`{categories}`	Post categories
`{tags}`	Post tags
`{post_type}`	WordPress post type
`{date}`	Publication/update date

A simple template could look like:

```markdown id="qjz8z2"

{title}

{excerpt}

Hot Post Alert

{title} just reached {milestone} views.

Current views: {views_short}
URL: {url}




Supported milestone-specific placeholders:

| Placeholder     | Description                                 |
| --------------- | ------------------------------------------- |
| `{views}`       | Total view count, formatted with separators |
| `{views_short}` | Abbreviated view count such as `12.3K`      |
| `{milestone}`   | Threshold that was just crossed             |

Each milestone is sent once per post.

A post that jumps from 900 views to 12,000 views in one operation will not generate multiple Discord messages. The plugin sends only the highest milestone reached in that jump.

The same category/tag webhook routing used by publish/update notifications also applies to milestone alerts.

---

### Per-Category / Tag Webhook Routing

Per-term routing requires no custom code.

Open:



```plaintext
Posts → Categories → Edit
Posts → Tags → Edit

Then configure the Discord webhook fields for the term.

A term can have:

Discord Webhook URL
Username
Avatar URL
Only send to this webhook

The routing rules are straightforward:

No term webhook
    ↓
Global webhook only

Term webhook
    ↓
Term webhook + global webhook

"Only send to this webhook"
    ↓
Term webhook only

When several matching terms have dedicated webhooks, every unique webhook receives the notification once.

For example, if both Development and WordPress point to the same Discord webhook URL, that URL is still called only once for the post.

Developer Hooks

Init Pulse For Discord provides filters for developers who need to modify outgoing Discord payloads without editing plugin source code.

Modify the final publish/update payload:

```php id="1s0a4c"
add_filter( 'init_plugin_suite_pulse_for_discord_payload', function( $payload, $post_id, $context ) {
$payload['content'] .= "\n— Sent from my custom filter";

return $payload;

}, 10, 3 );




This filter runs once per post before the payload is dispatched to the resolved destinations, so the modification applies to the global webhook and per-term webhooks alike.

Webhook `username` and `avatar_url` overrides are resolved per destination afterward.

For Hot Post Milestones, use:



```php id="v4y4cg"
add_filter( 'init_plugin_suite_pulse_for_discord_milestone_payload', function( $payload, $post_id, $views, $milestone ) {
    $payload['content'] .= "\nMilestone: {$milestone} views!";

    return $payload;
}, 10, 4 );

This gives developers a simple extension point for adding custom content, mentions, metadata, or application-specific information to the final Discord payload.

Webhook Delivery

The plugin keeps webhook delivery deliberately lightweight.

It includes:

Configurable request timeout
Retry handling
Discord rate-limit support
429 Retry-After handling
Success/error delivery logging
Separate delivery records for multiple destinations

There is no Discord SDK to install and no external package manager dependency.

The plugin communicates with Discord through its standard webhook endpoint.

Settings

Navigate to:

Settings → Init Pulse For Discord

Available settings include:

Post Types — select which post types trigger notifications
Webhook URL — global Discord webhook destination
Send Test Message — verify the webhook immediately
Bot Username — global webhook username
Avatar URL — global webhook avatar
Include Featured Image — add the post thumbnail to the embed
Use Rich Embed — switch between embed and plain-text output
Embed Color — customize the Discord embed accent
Timeout / Retries — configure webhook delivery behavior
Message Template — Markdown-ready publish/update template
Notify on View Milestones — enable Hot Post Milestone alerts
View Milestones — configure thresholds such as 1000, 5000, 10000
Milestone Message Template — separate template for view milestones

The settings screen also contains the Delivery Log for recent webhook results.

Role IDs and per-term webhook destinations are configured directly on individual categories and tags.

Installation

Install from WordPress.org or manually upload the plugin to:

/wp-content/plugins/

Then:

Activate Init Pulse For Discord
Go to Settings → Init Pulse For Discord
Paste your Discord webhook URL
Click Send Test Message
Choose which post types should trigger notifications
Optionally assign Discord Role IDs to categories or tags
Optionally configure dedicated webhooks for categories or tags
Optionally install Init View Count and enable Hot Post Milestones

That's it.

Publish a tracked post and Discord receives the notification through your configured webhook destination.

Safe by Default

Init Pulse For Discord does not attempt to take over WordPress publishing behavior.

It listens to the relevant WordPress hooks and sends notifications when configured conditions are met.

Optional features remain optional:

Update notifications
Role mentions
Per-category/tag webhooks
Hot Post Milestones
Featured images
Rich embeds

Nothing extra is silently enabled just because another plugin happens to be installed.

For example, Init View Count integration remains dormant until you explicitly enable Notify on View Milestones.

Where Data Lives

Init Pulse For Discord keeps its storage footprint intentionally small.

Delivery history is stored in wp_options
Delivery logs use autoload = no
No custom database tables
No external notification database
No frontend storage
No per-page frontend assets

The goal is simple: keep the plugin focused on webhook delivery rather than turning notifications into another subsystem your WordPress database has to carry around.

Part of the Init Plugin Suite

Init Pulse For Discord is part of the Init Plugin Suite — a collection of lightweight, performance-focused WordPress plugins built for developers and creators who prefer clean implementations over feature-heavy stacks.

WordPress publishes.

Init Pulse routes the pulse.

Discord gets the message.

Thanks for reading. Got feedback or questions?

→ WordPress.org
→ GitHub

Init Void Shield – Zero-DB, Honeypot, Anti-Spam for WordPress

Hao Nguyen — Tue, 29 Sep 2026 05:26:18 +0000

Init Void Shield is a lightweight, zero-database honeypot anti-spam plugin for WordPress comments, core forms, WooCommerce, bbPress, BuddyPress, Contact Form 7, WPForms, Gravity Forms, and more.

No CAPTCHA. No external JavaScript. No database tables. No user friction.

It uses layered, context-bound honeypot protection, signed time tokens, delayed browser verification, headless-browser detection, non-browser User-Agent detection, and cross-site submission blocking to stop automated submissions while keeping the experience invisible to real users.

Why Init Void Shield?

Spam protection often comes with a trade-off: either annoy real users with CAPTCHA challenges or add another heavy plugin full of JavaScript, tracking, external services, and database records.

Init Void Shield takes a different approach.

The core comment guard is always enabled and requires no configuration to start protecting a site. Additional guards are explicitly opt-in, so enabling a new feature in a plugin update never silently changes which forms are protected.

The plugin is designed to be:

Invisible to humans — no CAPTCHA, puzzles, or extra UI
A void to bots — honeypots, signed tokens, browser verification, and behavioral checks
Zero-DB — no custom tables and no per-submission logs
Cache-aware — optional Lazy Fetch refreshes tokens on genuinely loaded pages
Developer-friendly — a full filter API lets you customize almost every layer

It's part of the Init Plugin Suite and follows the same minimalist, performance-first philosophy.

Features at a Glance

Layered Honeypot Protection

Dynamic honeypot field names derived from context and site salt
Optional custom field-name prefix
CSS-clipped text and checkbox traps instead of display:none or visibility:hidden
Rotating CSS hiding techniques and trap field order
Signed, context-bound, self-expiring time tokens
HMAC verification with hash_equals() to prevent timing attacks
Per-form signed JavaScript proofs
Configurable JavaScript delay with random jitter
Headless-browser detection for common automation signals
Selenium / ChromeDriver automation marker detection
Non-browser User-Agent detection
Cross-site submission blocking via Sec-Fetch-Site

Human-Friendly UX

No CAPTCHA
No external JavaScript
No CDN dependencies
No additional fields visible to visitors
Logged-in users bypass comment verification by default
Submit Hold automatically waits for the guard when a real visitor submits too quickly, such as immediately after browser autofill

A genuine visitor is never asked to solve anything. The protection happens in the background.

WordPress Core Forms

Optional protection for:

Login
Registration
Lost Password
Multisite Signup

Each guard is independently configurable and disabled by default.

Form Plugin Integrations

One-click protection for:

Contact Form 7
WPForms
Gravity Forms

The integration activates only when the corresponding plugin is detected as active.

WooCommerce & Community Integrations

Optional protection for:

WooCommerce Registration
WooCommerce Login
WooCommerce Lost Password
bbPress New Topic
bbPress Reply
BuddyPress Registration

These integrations are also opt-in and automatically detect whether the target plugin is active.

Comment Content Filtering

Behavioral honeypot checks are not always enough. Init Void Shield also provides optional content-based rules that inspect what was actually submitted:

Maximum Links per Comment
Block BBCode Links
Block URLs in Author Name

These filters can catch spam even when the submission comes from a real browser or bypasses the normal honeypot flow.

Cache-Safe Protection

Aggressively cached WordPress sites can create a subtle problem: a timestamp generated when a page was cached is not the same as the time a real visitor loaded the page.

Lazy Fetch solves that by refreshing the time token and signed JavaScript proof through a small same-origin fetch() request after the page genuinely loads.

No jQuery. No external API. If the request fails, Init Void Shield falls back to the original token.

Lightweight Statistics

Blocked submission counter
Statistics by channel
Statistics by reason
No per-submission logging
No personal data storage
Stored as a single non-autoloaded WordPress option
Optional Dashboard widget

Core Defense Layers

Layer	What it does
Dynamic Honeypots	Generates context-specific hidden trap fields
CSS Trap Rotation	Randomizes how honeypots are hidden and ordered
Signed Time Token	Prevents instant submissions and token replay
Signed JS Proof	Verifies the expected browser-side execution for that exact form
Headless Detection	Detects common Selenium, Puppeteer, Playwright, and headless-browser signals
Non-Browser UA Detection	Blocks scripted HTTP clients such as curl, Python requests, HTTPX, aiohttp, axios, and similar clients
Cross-Site Blocking	Rejects submissions reported by the browser as `Sec-Fetch-Site: cross-site`
Real User Interaction	Optionally requires mouse, keyboard, touch, or scroll activity
Same-Site Referer	Optionally validates the Referer header on comment submissions
Content Filters	Optionally blocks excessive links, BBCode links, and URLs in author names
REST API Guard	Optionally blocks direct comment creation through `wp/v2/comments`
Submit Hold	Temporarily holds early native submissions until the browser guard is ready
Soft Kill	Returns HTTP 200 OK to comment bots so they believe the submission succeeded

How It Works

When a visitor opens a guarded form, Init Void Shield injects a set of protection values specific to that form.

A simplified flow looks like this:

Visitor loads form
       ↓
Dynamic honeypots generated
       ↓
Signed time token issued
       ↓
Delayed JS proof scheduled
       ↓
Browser loads and verifies itself
       ↓
Visitor fills and submits form
       ↓
Server validates all enabled gates
       ↓
   ┌───────────────┐
   │ Valid human?  │
   └───────┬───────┘
           │
      ┌────┴────┐
      │         │
     YES        NO
      │         │
   Accept     Reject

On submission, the server can validate:

The browser does not report the request as cross-site.
The User-Agent does not identify a known scripted HTTP client.
Honeypot fields remain empty.
The signed JavaScript proof is present and matches the exact form and time token.
No headless-browser or automation signal is reported.
The time token is valid and bound to the form that issued it.
The submission is not too fast.
The token has not expired.
Optional same-site Referer requirements are satisfied.
Optional comment content rules pass.

If any enabled check fails, the submission is rejected.

For the core comment form, the response can intentionally remain HTTP 200 OK so automated spam software cannot easily distinguish a successful submission from a blocked one.

Core Modules

Module	What it does
Comment Guard	Always-on layered honeypot protection for WordPress comments
Core Form Guards	Optional login, registration, lost-password, and Multisite signup protection
Form Integrations	Contact Form 7, WPForms, and Gravity Forms
WooCommerce Guards	Registration, login, and lost-password protection
Community Guards	bbPress topics/replies and BuddyPress registration
Content Filters	Link limits, BBCode link blocking, and URL detection in names
Headless Detection	Detects browser automation signals without external services
User-Agent Blocking	Rejects scripted HTTP clients
Cross-Site Protection	Uses `Sec-Fetch-Site` to detect cross-site submissions
Lazy Fetch	Refreshes tokens after real page load for cached environments
Submit Hold	Prevents genuine early submissions from being rejected
Statistics	Lightweight blocked-submission counters
Dashboard Widget	Optional blocked-submission summary in wp-admin

Developer Hooks

Init Void Shield is designed for developers who want precise control without modifying plugin core files.

For example, you can bypass verification for a specific request:

add_filter( 'init_plugin_suite_void_shield_skip_verification', '__return_true' );

Force-disable a specific WordPress core form guard:

add_filter( 'init_plugin_suite_void_shield_skip_login_verification', '__return_true' );
add_filter( 'init_plugin_suite_void_shield_skip_register_verification', '__return_true' );
add_filter( 'init_plugin_suite_void_shield_skip_lostpassword_verification', '__return_true' );
add_filter( 'init_plugin_suite_void_shield_skip_multisite_signup_verification', '__return_true' );

Add your own comment content rule:

add_filter( 'init_plugin_suite_void_shield_comment_content_violation', function ( $reason, $commentdata ) {
    // Return a non-empty reason key to block the comment.
    // Return an empty string to allow it through.
    return $reason;
}, 10, 2 );

Customize the honeypot markup:

add_filter( 'init_plugin_suite_void_shield_honeypot_html', function ( $html, $context ) {
    return $html;
}, 10, 2 );

Customize the minimum submit time and token lifetime:

add_filter( 'init_plugin_suite_void_shield_min_time', function ( $seconds, $context ) {
    return 5;
}, 10, 2 );

add_filter( 'init_plugin_suite_void_shield_max_time', function ( $seconds, $context ) {
    return 7200;
}, 10, 2 );

Customize the JavaScript delay:

add_filter( 'init_plugin_suite_void_shield_js_delay', function ( $milliseconds ) {
    return 1500;
} );

Customize the random delay jitter:

add_filter( 'init_plugin_suite_void_shield_js_delay_jitter_max', function ( $milliseconds ) {
    return 600;
} );

Add your own non-browser User-Agent signature:

add_filter( 'init_plugin_suite_void_shield_blocked_user_agent_signatures', function ( $signatures ) {
    $signatures[] = 'my-internal-test-client';

    return $signatures;
} );

Force-exempt a request from cross-site submission blocking:

add_filter( 'init_plugin_suite_void_shield_cross_site_exempt', function ( $exempt, $context ) {
    return $exempt;
}, 10, 2 );

Control Submit Hold for a custom guard context:

add_filter( 'init_plugin_suite_void_shield_submit_hold_enabled', function ( $enabled, $context ) {
    return $enabled;
}, 10, 2 );

Customize how long Submit Hold waits for Lazy Fetch:

add_filter( 'init_plugin_suite_void_shield_submit_hold_fetch_wait', function ( $milliseconds, $context ) {
    return $milliseconds;
}, 10, 2 );

The plugin also exposes filters for CSS trap variants, login scope exemptions, Referer checks, interaction timing, blocked messages, soft-kill response codes, and more.

Soft-Kill Responses

For comment spam, Init Void Shield can intentionally return a successful HTTP status instead of exposing an obvious block response.

add_filter( 'init_plugin_suite_void_shield_kill_response_message', function ( $msg ) {
    return 'Spam detected.';
} );

add_filter( 'init_plugin_suite_void_shield_kill_response_title', function ( $title ) {
    return 'Blocked';
} );

add_filter( 'init_plugin_suite_void_shield_kill_response_code', function ( $code ) {
    return 200;
} );

The default response code is 200, which makes the request look successful from the perspective of a basic spam bot.

Cache-Safe Tokens

Full-page caching introduces a classic anti-spam problem.

Imagine a page containing a token generated at 10:00 AM, cached by the server, and served to visitors at 12:00 PM. The token may now represent the cache time rather than the actual browser session.

Init Void Shield's Lazy Fetch feature refreshes the time token and signed JavaScript proof immediately after the page genuinely loads.

Cached HTML
    ↓
Page loads in browser
    ↓
Same-origin fetch()
    ↓
Fresh signed token + JS proof
    ↓
Visitor submits
    ↓
Server validates fresh values

The request uses plain JavaScript and has no dependency on jQuery.

This is particularly useful on sites using aggressive full-page caching or CDN caching.

Login Guard Scope

The Login Guard supports two modes:

Everywhere

Protect both:

wp-login.php
wp_login_form()

wp-login.php only

Protect only the native WordPress login page while leaving front-end wp_login_form() usage untouched.

This is useful when a custom front-end login form lives on a page that may be served through full-page caching and should remain unguarded.

Where Data Lives

Init Void Shield is intentionally designed to keep its footprint close to zero.

No custom database tables
No per-submission records
No personal data stored for statistics
One non-autoloaded WordPress option for lightweight counters
No external anti-spam service
No external JavaScript or CDN dependency

That means less database clutter and less runtime overhead compared with systems that persist every blocked request.

Settings

Navigate to:

Settings → Init Void Shield

The settings are grouped by protection layer.

Comments

Configure the core comment guard, logged-in user bypass, REST API protection, Referer validation, and optional content filters.

Timing & Token Engine

Tune:

Minimum Submit Time
Account Forms Minimum Submit Time
JavaScript Token Delay
Maximum Token Age

The separate account-form threshold is useful because browser autofill can allow legitimate login or registration submissions to happen much faster than a normal content form.

WordPress Core Forms

Enable protection individually for:

Login
Registration
Lost Password
Multisite Signup

Form Plugin Integrations

Enable guards for:

Contact Form 7
WPForms
Gravity Forms

Only detected active plugins are eligible.

Community & E-commerce Integrations

Enable guards for:

WooCommerce Registration
WooCommerce Login
WooCommerce Lost Password
bbPress Topics & Replies
BuddyPress Registration

Advanced Protection

Configure:

Custom Field Prefix
CSS Trap Rotation
Headless Browser Detection
Non-Browser User-Agent Blocking
Cross-Site Submission Blocking
Real User Interaction
Lazy Fetch

Statistics

Track blocked submissions by channel and reason using the lightweight non-autoloaded statistics option.

You can also enable the optional Dashboard widget.

Safe by Default

Init Void Shield follows an intentionally conservative activation model.

The comment guard is enabled by default.

Everything else is opt-in.

That means activating a new integration does not silently start modifying a login page, WooCommerce form, or community form simply because a supported plugin happens to be installed.

You decide which surfaces should be protected.

Upgrading to 1.11

Version 1.11 introduces a new signed, per-form JavaScript proof instead of relying on a fixed JS token value.

After upgrading, purge your page cache and CDN cache once.

A page still being served from a pre-1.11 cache contains the old script. Submissions from that stale HTML can fail with an Invalid JS proof reason until the cache is refreshed.

Version 1.11 also adds:

Submit Hold for early native submissions
Selenium / ChromeDriver automation detection
Extended non-browser User-Agent detection
Cross-site submission blocking
Comment content filters
WooCommerce Login protection
WooCommerce Lost Password protection
Signed per-form JS proofs

Installation

Install via WordPress.org or clone the repository:

git clone https://github.com/brokensmile2103/init-void-shield.git

Then:

Upload the plugin to /wp-content/plugins/ if installing manually
Activate Init Void Shield
Go to Settings → Init Void Shield
Review the comment protection settings
Enable any optional core form, form plugin, WooCommerce, bbPress, or BuddyPress guards you need

That's it.

Your WordPress comments are protected out of the box, while every additional guard stays under your control.

Part of the Init Plugin Suite

Init Void Shield is part of the Init Plugin Suite — a collection of minimalist, high-performance WordPress plugins built for developers and creators who care about speed, clean architecture, and practical UX.

No bloat. No unnecessary services. No CAPTCHA.

Just a quiet layer between your forms and automated spam.

Thanks for reading. Got feedback or questions?

→ Project Page
→ GitHub

Share Code & Notes Instantly with Init Note — No Account, No Setup

Hao Nguyen — Wed, 22 Jul 2026 06:16:03 +0000

Need to send a teammate a config file, a stack trace, or a quick checklist without opening Slack threads or spinning up a Gist? Init Note turns any text — plain notes or syntax-highlighted code — into a shareable link in seconds. Type or paste, hit save, get a link. Done.

No account. No install. No friction.

What is Init Note?

Init Note is a free online pastebin/notepad hybrid built for speed. You type or paste content into a live editor with real syntax highlighting for 15+ languages (JavaScript, TypeScript, PHP, Python, HTML, CSS, SQL, Bash, Go, Rust, Java, C, C++, JSON, Markdown), hit "Save & Get Link", and you have a URL anyone can open instantly — no login required on either end.

The editor also runs in Markdown mode, and here's the part developers actually love: you can paste an image directly with Ctrl + V, and it's automatically uploaded and inserted into the note as Markdown — no separate image host, no manual linking.

Perfect for:

Sharing a code snippet or config with a teammate
Sending a stack trace to get help debugging
Quick notes and checklists during a meeting or while on the move
Sensitive, one-time content that should self-destruct after being read
Writing a quick Markdown doc with screenshots pasted straight in

How to Share a Note in Under 30 Seconds

Go to note.inithtml.com and start typing or pasting.
Pick a language, or let it auto-detect from what you pasted.
Optionally set a custom slug, a password, or self-destruct-after-read.
Hit "Save & Get Link" (or Ctrl + S).
Copy the link or scan the QR code — the recipient sees it instantly, no login needed.

Example:

Paste a stack trace → language auto-detected as JavaScript → save → send the link in Slack → your teammate sees it fully highlighted, no formatting lost.

Full How-To Guide

Step 1: Write or Paste Your Content

Open the editor and start typing, or paste in code, logs, or plain text. Switch to Markdown mode if you're writing documentation or notes with formatting.

Step 2: Drop In Images with Ctrl + V

This is the standout feature for Markdown notes: drag-and-drop an image, or just paste one straight from your clipboard, and Init Note uploads it and inserts the Markdown image syntax at your cursor automatically. No hunting for an image host, no manual ![]() linking.

It pairs especially well with Init Clipboard Image when you're writing a customer-facing guide or tutorial: take a screenshot, annotate it in Init Clipboard Image (arrows, highlights, step numbers), copy the result with Ctrl + C, then paste it straight into your Init Note with Ctrl + V. The annotated image is uploaded and inserted as Markdown instantly — so your whole how-to article, screenshots included, comes together in one continuous workflow.

Step 3: Pick a Language (or Skip It)

Choose from 15+ supported languages, or let the editor auto-detect the language when you paste code — it applies the right highlighting automatically.

Step 4: Customize the Link (Optional)

Set a custom slug so the URL is memorable (note.inithtml.com/your-name) instead of a random string.

Step 5: Add Protection (Optional)

Password — lock the note so only people with the password can read it. Good for long-lived, private shares.
Self-destruct after read — the note is permanently deleted after the first view. Good for one-time secrets like tokens or temporary credentials.

Step 6: Save and Share

Hit "Save & Get Link" or Ctrl + S. A QR code appears immediately in the result window — handy for sharing to a phone. Copy the link, or save the Edit Key you're given if you want to edit or delete the note later.

Step 7: Manage Your Notes

Every note you create on a device shows up under "My Notes", so you don't have to keep track of links manually. Notes are auto-deleted after 30 days of no access.

Key Features

Real syntax highlighting — 15+ languages, colored live as you type, not just monospaced plain text
Auto language detection — paste code, get the right highlighting automatically
Markdown mode with image paste — Ctrl + V an image and it's uploaded and inserted as Markdown instantly
Instant shareable link — every note gets its own URL plus an auto-generated QR code
Custom slug — memorable, brandable links
Password protection — for long-term, private sharing
Self-destruct after read — for one-time, sensitive content
Edit Key — edit or delete a note anytime with a private key
Word wrap toggle — especially useful reading notes on mobile
Note history — see every note you've created on a device under "My Notes"
Bilingual UI — English/Vietnamese, auto-detected from your browser
Fully responsive — works well on desktop and mobile alike

Real-World Use Cases

Developers — share a code snippet, config file, or script with a colleague via one link.
Teams — send instructions, checklists, or meeting notes without opening email or a doc tool.
Technical support — paste an error log or stack trace and get it reviewed with full syntax highlighting intact.
On-the-go notes — jot something down quickly, pick it back up from any device.
Sensitive info — use self-destruct-after-read for one-time secrets, or a password for longer-lived private notes.
Teaching — share exercises, code examples, or reference material through a direct link.
Quick Markdown docs — write notes with pasted screenshots included, no separate image hosting step.

Why Use Init Note?

No account, no install
Actual syntax-highlighted editor, not just a plain textbox
Auto language detection when you paste code
Markdown mode with clipboard image paste built in
Password protection for private, long-lived shares
Self-destruct mode for sensitive, one-time content
QR code generated automatically — easy to hand off to mobile
Links work for 30 days, no login required to view
Minimal, distraction-free interface
Custom slugs for links that actually mean something

Try It Out

Head to Init Note, paste a snippet or drop in some Markdown with an image or two, and see how fast you get a shareable link. If it becomes part of your daily workflow, I'd love to hear how you're using it in the comments.

Convert, Resize & Watermark Images 100% in Your Browser with Init Magick Studio

Hao Nguyen — Wed, 22 Jul 2026 06:05:47 +0000

Need to batch-convert a folder of PNGs to WebP, resize a hundred product photos to a social preset, strip GPS data before sharing, and slap a watermark on everything — without uploading a single file to a server? Init Magick Studio does the whole pipeline, right in your browser, powered by ImageMagick compiled to WebAssembly.

No account. No install. No upload. Just drag, convert, download.

What is Init Magick Studio?

Init Magick Studio is a free, browser-based image converter built on ImageMagick WASM — the same engine behind countless professional image pipelines, running entirely client-side. Every operation (format conversion, resize, compression, EXIF stripping, watermarking) happens on your device. Nothing is ever sent to a server, nothing is stored in the cloud.

It supports 100+ image formats — JPEG, PNG, WebP, AVIF, GIF, BMP, TIFF, RAW, and more — with smart resizing, Entropy-based smart crop, quality control, metadata removal, custom watermarks, and one-click ZIP export.

Perfect for:

Batch format conversion for web performance (PNG → WebP/AVIF)
Resizing images to exact social media dimensions
Stripping EXIF/GPS before sharing sensitive photos
Watermarking a whole batch of images at once
Any image job you'd rather not upload to a random online converter

How to Convert a Batch of Images in Under a Minute

Open the tool and drag in your images (or click to select).
Pick an output format — JPEG, PNG, WebP, AVIF, GIF, TIFF, or BMP.
Optionally set dimensions, or just pick a preset (Story, Square, A4, 4K...).
Optionally tweak quality, strip metadata, or add a watermark.
Hit "Convert & Download ZIP".

Example:

Drop in 40 product photos → output as WebP → preset "Social" → Privacy Mode on → watermark logo bottom-right → one ZIP, ready to upload to your store.

Full How-To Guide

Step 1: Add Your Images

Drag and drop or click to select files. There's no cap on batch size — process 1 image or 100, limited only by your browser's memory.

Step 2: Choose Output Format

JPEG for photos, PNG for lossless, WebP or AVIF for modern, smaller web-ready files, or GIF/TIFF/BMP if that's what you need.

Step 3: Set Dimensions (Optional)

Enter width/height manually, or grab one of the 13 built-in presets: FHD, Story, Square, Social, Thumb, A4, 4K, 2K, HD, Banner, FB Cover, IG Post, YT Thumb. Leave it empty to keep the original size.

If you enter both width and height, you can also enable Smart Crop — it runs an Entropy analysis to automatically keep the highest-detail region of the image instead of a naive center crop. Great for thumbnails and avatars.

Step 4: Adjust Compression Quality

A quality slider from 1–100 (default 85) lets you balance file size against visual fidelity.

Step 5: Toggle Privacy Mode

Strips EXIF, GPS tags, camera profiles, and other device metadata. It's on by default — worth knowing if you actually want to keep that data.

Step 6: Add a Watermark (Optional)

Upload a watermark image (transparent PNG supported), place it on a 3×3 position grid, and adjust size (as % of image width) and opacity.

Step 7: Convert & Download

Click "Convert & Download ZIP" or press Ctrl + Enter. First run downloads the WASM engine (~14MB, cached afterward). Watch each file move through Pending → Processing → Done/Error in the log, then grab the ZIP — or download individual files straight from the list without waiting for the whole batch.

Key Features

100% client-side — powered by ImageMagick WASM, no upload, no server ever sees your images
100+ formats — read/write JPEG, PNG, WebP, AVIF, GIF, BMP, TIFF, RAW, and more
Unlimited batch processing with a per-file progress bar
Smart Resize — proportional scaling by max width/height, or exact crop with both dimensions
Smart Crop (Entropy-based) — auto-keeps the highest-detail region
13 dimension presets for social, print, and banner formats
Compression quality control with live size preview
Privacy Mode — strips EXIF/GPS/metadata, on by default
Custom watermark — position, size, and opacity control, transparent PNG supported
Automatic ZIP export, smart-compressed per format (STORE for PNG/AVIF/WebP, DEFLATE for JPEG/BMP)
Individual downloads per file, no need to wait for the batch
Detailed processing log — every step timestamped, per-file status
Space savings display — original vs. new size with a ↓%/↑% badge
Bilingual UI — English/Vietnamese, auto-detected, saved to localStorage
Keyboard shortcut — Ctrl + Enter to start conversion

Real-World Use Cases

Developers & Designers — batch-convert PNGs to WebP/AVIF for smaller, faster-loading websites.
Marketing & Content Creators — resize to exact social dimensions in one drag-and-drop using built-in presets.
Photographers — convert RAW to JPEG, export lossless PNG for print, strip GPS before sharing, add copyright watermarks.
SEO & Web Performance — bulk-optimize an image library to next-gen formats to improve load times and Core Web Vitals.
Quick Sharing — compress screenshots or phone photos to fit email/chat size limits.
Privacy-First Processing — handle IDs, contracts, or sensitive documents with zero server exposure.
Education — convert diagrams and illustrations for slides and documents.
Photo Library Management — strip redundant metadata to shrink files and save cloud storage.

Why Use This Tool?

No registration, no software install
100% client-side — your images never leave your device
Powered by ImageMagick WASM, a genuinely professional-grade engine
100+ formats, unlimited batch size
Smart Crop, presets, watermarking, and metadata stripping all in one place
Clean, dark, ad-free interface
Works on any modern browser — desktop, laptop, tablet, or phone

Try It Out

Head to Init Magick Studio, drop in a batch of images, and see how fast a fully local, no-upload converter can be. If it saves you time on a real workflow, I'd genuinely like to hear about it in the comments.

Annotate Screenshots Instantly in Your Browser with Init Clipboard Image

Hao Nguyen — Wed, 22 Jul 2026 05:54:54 +0000

Ever needed to quickly mark up a screenshot — circle a bug, blur out an email address, number the steps of a tutorial — without opening Photoshop or installing yet another app? Init Clipboard Image does exactly that, right in your browser, in seconds.

Paste, draw, blur, crop, copy back to clipboard. No install, no upload, no signup.

What is Init Clipboard Image?

Init Clipboard Image is a free, 100% client-side screenshot annotation tool. You paste an image straight from your clipboard (Ctrl + V), drag & drop a file, or pick one from your computer — then mark it up with a full annotation toolkit and copy or download the result instantly.

Everything runs locally in the browser. Nothing is ever uploaded to a server, which makes it a solid choice for screenshots that contain sensitive info you're about to blur out anyway.

Perfect for:

Bug reports & QA testing
Step-by-step tutorials and documentation
Design/UI feedback
Redacting sensitive data before sharing
Quick edits on anything you copy from chat, email, or docs

How to Annotate a Screenshot in Under a Minute

Copy a screenshot from anywhere (or have an image file ready).
Paste it into the tool with Ctrl + V, drag & drop it, or click to browse.
Pick a tool — pencil, highlighter, arrow, rectangle, X mark, blur, crop, step marker, or text note.
Mark up the image: highlight the bug, draw an arrow, blur out a token, number the steps.
Copy the result back to your clipboard (Ctrl + C) or download it (Ctrl + S).

Example:

Paste a UI screenshot → draw an arrow at the broken button → add a text note "this throws a 500" → copy and paste straight into your bug tracker.

Full How-To Guide

Step 1: Get an Image In

Paste with Ctrl + V, drag & drop a file onto the page, or click to open the file picker. JPG, PNG, and WebP are all supported.

Step 2: Pick Your Tool

The toolbar covers everything you'd actually reach for on a screenshot:

Pencil — freehand drawing
Highlighter — soft, marker-style highlight, great for docs and screenshots
Arrow — point at exactly what matters
Rectangle — frame a section of the image
X Mark — click to mark a spot, Ctrl + Click to cross out the whole image
Blur / Pixelate — redact emails, phone numbers, tokens, API keys
Crop — trim to just the part you need
Step Marker — auto-numbered stamps for tutorials, click to place 1, 2, 3...
Text Note — inline, multi-line text directly on the image

Step 3: Fine-Tune Stroke & Font Size

Both line thickness and font size auto-scale to the image's resolution, so annotations look consistent whether you're marking up a tiny icon or a 4K screenshot. Hold Shift while drawing to snap lines to a straight horizontal or vertical axis.

Step 4: Undo/Redo as Needed

Full undo/redo history (Ctrl + Z / Ctrl + Y) so you can experiment freely.

Step 5: Copy or Download

Hit Copy Image to send the annotated image straight to your clipboard — ready to paste into Slack, an issue tracker, or an email — or Download to save it as a file.

Keyboard Shortcuts

Key	Action
`B`	Pencil
`H`	Highlighter
`A`	Arrow
`X`	X mark
`R`	Rectangle
`M`	Blur / Pixelate
`K`	Crop
`N`	Step marker
`T`	Text note
`Shift`	Snap line to horizontal/vertical
`Ctrl + C`	Copy image to clipboard
`Ctrl + S`	Download image
`Ctrl + Z`	Undo
`Ctrl + Y`	Redo
`Delete` / `Backspace`	Clear current image
`?`	Show shortcut cheat sheet

Real-World Use Cases

Bug reports & QA — highlight, arrow, or X-mark the exact issue instead of writing a paragraph describing where it is.
Tutorials & docs — use the Step Marker to number a sequence of UI actions in seconds.
Design review — annotate a Figma export or a live site screenshot with direct feedback.
Privacy before sharing — blur out emails, phone numbers, tokens, and API keys before posting a screenshot publicly.
Teaching — highlight key parts of a slide or document to explain visually.
Everyday quick edits — mark up anything from chat, email, or docs without switching apps.

Why Use This Tool?

Zero setup — open the page, start pasting.
No upload — all processing happens on your device.
Full toolkit — draw, highlight, arrow, blur, crop, number, and annotate with text, all in one place.
Auto-scaling — stroke width and font size adapt to image resolution automatically.
Clipboard-first workflow — paste in, copy out, no file management required.
Works everywhere — modern Chrome, Edge, Firefox, and Safari.

Tips for Faster Annotation

Learn the single-letter shortcuts (B, H, A, X, M...) — switching tools becomes instant.
Use Shift when drawing arrows or rectangles to keep them perfectly straight.
Blur first, annotate second, if a screenshot has sensitive data — one less thing to forget.
Use Step Marker instead of manually typing numbers for anything with more than 3 steps.

Try It Out

Head over to Init Clipboard Image and paste your first screenshot — it takes less time than opening an image editor. If you build something useful with it (a bug report template, a tutorial workflow), share it in the comments!

Init User Engine – A gamified, frontend-first user system for WordPress

Hao Nguyen — Wed, 22 Jul 2026 05:37:11 +0000

Init User Engine is a lightweight, no-bloat user system for modern WordPress sites. It replaces the default profile/login experience with a full gamification layer — EXP & levels, a Coin/Cash wallet, daily check-in, VIP membership, referrals, and an inbox — all rendered through a fast, modal-driven frontend powered by the REST API.

No jQuery. Minimal settings. Smart by default.

Why Init User Engine?

Most "membership" or "points" plugins for WordPress are heavy, admin-ajax-based, and hard to theme. Init User Engine takes the opposite approach: everything dynamic — avatar, dashboard, check-in, inbox, VIP purchase — is rendered client-side in pure Vanilla JS and talks to a clean REST API. Drop in one shortcode and you get a full gamified account system on top of native WordPress users.

It's the core user system behind the Init Plugin Suite — the same minimalist, performance-first philosophy as Init Live Search.

Features at a Glance

Gamified Progression

EXP & Level system with fully hookable progression logic
Coin & Cash wallet with transaction logs (dedicated DB tables, not user meta)
Daily check-in with streak milestones and an online-time bonus timer
Daily task list, extensible via filter

Frontend-First UX

One shortcode: [init_user_engine] — avatar button + full modal dashboard
Avatar system with upload, live preview, and revert-to-default support
Login/Register modals for logged-out visitors, with custom redirect URLs
Pure Vanilla JS — no jQuery, no server-rendered admin-ajax round trips

Monetization & Retention

VIP membership, purchased with in-site Coin, with configurable duration tiers (including lifetime)
VIP bonus system — extra Coin/EXP percentage for VIP members
Redeem Code / Gift Code module — generate single-use or bulk codes, redeem for rewards
Referral module with cookie-based signup tracking and rewards for both sides

Communication

Built-in inbox with pagination, category filters (System, Rewards, Activity...), read/claim/delete
Admin panel to send notifications to selected users or the whole member base, with priority and expiration

Built for Developers

REST API for every feature — register, check-in, claim reward, inbox, VIP purchase, redeem code, profile, and more
Deep set of action/filter hooks: modify EXP curves, VIP prices, referral rewards, theme colors, VIP body classes, and more
Transaction and EXP logs stored in dedicated tables with wp_cache support and true paginated queries — built to scale, not just to demo

Core Modules

Module	What it does
EXP & Level	Award EXP via hook, auto level-up, customizable EXP curve per level
Wallet (Coin/Cash)	Dual-currency system with full transaction history
Check-in	Daily rewards, streak milestones, online-duration bonus
VIP	Coin-based purchase, expiry tracking, bonus % on rewards
Referral	Cookie-based tracking, rewards for referrer and new user
Redeem Code	Single-use or bulk gift codes redeemable for Coin/Cash
Inbox	Filterable, paginated notification center per user
Admin Notify	Send targeted or broadcast messages from wp-admin

REST API

Base: /wp-json/inituser/v1/

Endpoint	Purpose
`POST /register`	Create a new user account
`POST /checkin`	Daily check-in
`POST /claim-reward`	Claim reward after online duration
`GET /transactions`	Coin/Cash transaction log
`GET /exp-log`	EXP log
`GET /inbox`	Inbox messages
`POST /vip/purchase`	Purchase VIP package
`GET /referral-log`	Referral history
`POST /avatar`	Upload new avatar
`GET /profile/me`	Current user profile
`POST /exchange`	Convert Cash → Coin
`POST /redeem-code`	Redeem a gift code

👉 Full endpoint list in the plugin readme.

Developer Hooks

Init User Engine ships with a wide surface of filters and actions so you're never stuck waiting on a plugin update to customize behavior:

// Change how much EXP is required per level
add_filter( 'init_plugin_suite_user_engine_exp_required', function( $required, $level ) {
    return $level * 100;
}, 10, 2 );

// React to a level-up
add_action( 'init_plugin_suite_user_engine_level_up', function( $user_id, $new_level ) {
    // send a custom notification, unlock content, etc.
}, 10, 2 );

Other notable hooks include filters for VIP pricing, referral rewards, check-in milestones, daily tasks, theme colors, and VIP-related body classes — plus actions for EXP/Coin changes, referral completion, and admin notifications.

Where Data Lives

user_meta — EXP, level, Coin, Cash, VIP, referral
Dedicated DB tables — transaction log and EXP log (migrated off user meta for scalability as of v1.5.0)
wp_init_user_engine_inbox — inbox messages

Installation

Install via WordPress.org or:

git clone https://github.com/brokensmile2103/init-user-engine.git

Then:

Activate the plugin
Drop [init_user_engine] into any page, post, or template
Configure theme color, currency labels, and reward values under Settings → Init User Engine

That's it — modals and logic load automatically.

Part of the Init Plugin Suite

Init User Engine is part of the Init Plugin Suite — a set of minimalist, high-performance plugins built for WordPress developers and creators who value speed, flexibility, and clarity.

Thanks for reading. Got feedback or questions?
→ Project Page
→ GitHub

Tank 300IQ — A Smart Ricochet Tank Shooter Right in Your Browser

Hao Nguyen — Fri, 28 Nov 2025 03:57:47 +0000

🚀 Introducing Tank 300IQ — A Ricochet Tank Shooter With Adaptive AI

Play now: https://en.inithtml.com/tank-300iq/

If you enjoy fast-paced arena shooters, physics-style ricochet mechanics, and bots that actually learn, you’ll probably vibe with Tank 300IQ — a tiny-but-chaotic browser tank game where bullets bounce, tanks dash, and both sides shoot down incoming fire mid-air.

Runs directly in your browser (PC + Mobile), no downloads, no account — just play.

🎯 What Makes Tank 300IQ Special?

Tank 300IQ is built around smart ricochet combat and a tactical AI “brain” per difficulty. Each bot adapts based on how you play, storing its behavior profile in localStorage.

🧠 5 Difficulty Levels (Easy → Insane)

Bots can:

Lead shots and analyze angles
Perform ricochet & multi-bounce calculation
Read distance, danger, and advantage
Flank, spread out, crossfire, retreat or hold
Shoot down incoming bullets
Insane bots can even short-teleport (“blink”) to dodge
Use survival-weighted dodge vectors
Make shield-aware attack/retreat decisions

🔥 Game Modes

Classic

Fully customizable battles: difficulty, team sizes, bullet speed, bounce count, friendly fire…

Adventure

Multi-stage progression with unique maps and boss fights.

Survival / Endless

Random maps, scaling waves, increasing chaos.

Team Presets

Instant 1v1, 1vN, full squads, ally teams, anything you want.

🎮 Controls

PC:

Move: WASD / Arrow keys
Aim: Mouse
Fire: Click

Mobile:

Left joystick: Move
Right joystick: Aim + hold to fire

Supports manual control or auto-aim/auto-fire using the same tactical brain as the bots (great for mobile).

🛡️ Skills (Instant Cast)

PC:

1 — Shield
2 — Triple Shot
3 — Rally

Mobile:

Tap skill icons

Skill details:

Shield: Temporary bullet immunity
Triple Shot: Lane control, corner traps, multi-hit chains
Rally: Player-only squad charge — a well-timed all-in that can flip any match

🔧 Sandbox Settings

Tune almost anything:

Ally/enemy count
Difficulty
Tank & bullet speed
Max bounce
Friendly fire
Bullet break mode
And more…

Everything is saved in localStorage.

The entire game runs 100% client-side JavaScript.

🎮 Play Now

👉 Link: https://en.inithtml.com/tank-300iq/

If you discover a sick multi-bounce trickshot, let me know — I absolutely want to see it.

Init View Count – Accurate Post Views with REST API & Custom Shortcodes

Hao Nguyen — Thu, 26 Jun 2025 16:11:18 +0000

A fast, minimalist view counter for WordPress – REST-first and developer-friendly

Init View Count tracks post views using JavaScript + REST API for precision and flexibility. It includes shortcodes, tabbed rankings, template overrides, and works with any post type.

No jQuery. No cookies. No fluff.

Features at a Glance

Lightweight and Accurate

Tracks views via REST API + scroll + delay logic
Prevents duplicates with session/localStorage
Optional batch mode: queue views and send in groups
Optional strict IP-based filtering (no raw IP storage)

Flexible Shortcodes

[init_view_count] – show current post view count
[init_view_list] – show list of most viewed posts
[init_view_ranking] – tabbed ranking by day/week/month/total
Fully theme-overridable templates (your-theme/init-view-count/*.php)
Format options: raw, formatted, short number, schema.org support

Clean Admin Tools

Dashboard widget to show top viewed posts
Settings panel to enable post types, batch, delay, scroll, etc.
Shortcode builders for all views with live preview

Minimal Overhead

No assets loaded unless shortcode used
CSS can be disabled completely
No tracking, no analytics bloat

Built for Developers

Custom meta key support via filters
Exposed REST API endpoints for tracking + top posts
Fully filterable output and query logic
Compatible with headless setups and SPAs

REST API Endpoints

`POST /wp-json/initvico/v1/count`

Record one or more post views.

Parameters:

post_id (int|array): One or more post IDs

`GET /wp-json/initvico/v1/top`

Retrieve top posts by views.

Parameters include:

range: total, day, week, month, trending
number: Number of posts
post_type, category, tag, etc.
fields: minimal or full
no_cache: Disable transient caching

👉 Full REST Guide

Shortcode Examples

Shortcode	Description
`[init_view_count]`	Show view count for current post
`[init_view_list]`	Most viewed posts list
`[init_view_ranking]`	Tabbed list by day/week/month/total

Add template, range, icon, schema, class, field, and other options as needed.

👉 Full Shortcode Guide

Dev Tools You Get

Filters like init_plugin_suite_view_count_should_count, *_meta_key, *_top_args
Modify output of /top API with init_plugin_suite_view_count_api_top_item
Theme override with view-list-sidebar.php, view-list-grid.php, etc.
Zero jQuery. Zero cookies. Fully modular JS.

Installation

Install via WordPress.org or:

git clone https://github.com/brokensmile2103/init-view-count.git

Then activate and configure in Settings → Init View Count.

Ways to show views:

Add [init_view_count] in post content
Use auto-insert (before/after post content)
Place view lists with [init_view_list]
Show trending or ranked tabs with [init_view_ranking]

Part of the Init Plugin Suite

Init View Count is part of the Init Plugin Suite – a set of minimalist, performance-first tools for WordPress developers.

Thanks for reading. Got feedback or ideas?

→ Project Page

→ GitHub

Create an Image Shuffle Minigame for Your Fanpage with Init Image Grid Shuffler

Hao Nguyen — Sun, 08 Jun 2025 14:31:35 +0000

Looking for a fun way to boost engagement on your social media or fanpage? Try creating a mini tile-shuffling game using Init Image Grid Shuffler — a lightweight, browser-based tool that lets you slice and scramble any image into a grid of tiles.

Let your followers guess the original picture, solve the tile order, or even race to win prizes. No Photoshop or code needed.

What is Init Image Grid Shuffler?

Init Image Grid Shuffler is a free online tool that splits an image into tiles and shuffles them. You can customize tile size, border, and difficulty level. Perfect for running:

Guess-the-image games
Puzzle-like challenges
Comment-based contests
Viral tag-your-friend posts

How to Create a Minigame

Here's how to build a fun image challenge in under 5 minutes:

Prepare an image that fits your theme (e.g., a character, product, or meme).
Upload it to the tool.
Choose how many rows and columns to split into (e.g., 5×5 = 25 tiles).
Generate the shuffled version.
Download and post it to your fanpage with a catchy caption or puzzle prompt.

Example:

“Can you guess what this image is? First 5 correct answers win a shoutout!”

Full How-To Guide

Step 1: Upload Your Image

Supported formats: JPG, PNG, WebP.

Use the “Choose an image…” button to upload.

Step 2: Pick Grid Size

Set how many rows and columns.

3×3 for casual players
5×5 or 7×7 for harder puzzles
Up to 10×10 if you’re evil 😈

Step 3: Customize Borders

Choose border thickness (suggested: 5px–10px).

The tool will smartly auto-pick black or white based on image brightness for best contrast.

Step 4: Generate the Shuffle

Click the “Generate shuffled image” button to preview. Adjust settings if needed.

Step 5: Download and Share

Click “Download image” and upload it to your social platform.

Step 6: (Optional) Show the Answer

Want to reveal or save the correct layout? Hit “Show answer” to see a numbered key.

Creative Minigame Ideas

Ask users to guess the image.
Let them comment the tile order (e.g., “3, 7, 1, 5…”).
Run a speed challenge – fastest correct answer wins.
Combine with tag-a-friend mechanics for viral reach.

Why Use This Tool?

Zero setup — works directly in browser.
No design skills required.
Smart contrast for clean puzzle visuals.
Optional answer key included.

Tips for Better Engagement

Use intriguing or funny images.
Set a timer or deadline to boost urgency.
Highlight or pin the best answers.
Pair with small giveaways for more participation.

Try it out

Go to Init Image Grid Shuffler and create your first puzzle. If you make something cool, share it in the comments — I’d love to see what you build!

Init Live Search – Smarter WordPress Search with Slash Commands & REST API

Hao Nguyen — Thu, 29 May 2025 05:26:45 +0000

A fast, flexible live search modal for WordPress – powered by REST API, Meilisearch & slash commands

Init Live Search replaces the default WordPress search with a modern modal. Built on the REST API, it works instantly, supports keyboard navigation, slash commands, and now offers optional Meilisearch integration for typo-tolerant, sub-50ms relevance-ranked search — with automatic fallback to the local database if Meilisearch is ever unreachable.

No jQuery. No page reloads. No broken search box, ever.

What's New in v1.9.x

Optional Meilisearch Integration — connect your own self-hosted or cloud Meilisearch instance as the primary search engine, with silent, automatic fallback to local DB search
Auto-sync to Meilisearch — posts are pushed/removed from the index on publish, update, trash, and delete (non-blocking)
WP-CLI Reindex — wp init-live-search meili-reindex for bulk indexing or full rebuilds
Cross-site Search — fetch & merge results from other Init Live Search-powered sites, no CORS or auth setup needed
New Shortcodes — [init_live_search] and [init_live_search_related_posts], both buildable visually via the new Shortcode Builder UI
AI-Powered Related Posts — [init_live_search_related_ai] using multi-signal scoring (tags, ACF, series, views, comments, freshness)
Template-based Layouts — grid, classic, compact, thumbright, overridable from your theme
404 Smart Redirect — automatically redirects broken URLs to the most relevant post
WooCommerce Slash Expansion — added /brand, /attribute, /variation, /coupon
Search Operators — +musthave and -mustnot terms now supported in queries

Features at a Glance

Minimalist, Modern UX

Modal-based UI (Ctrl + /, triple-click, data-ils)
Instant results via REST API (no admin-ajax, no jQuery)
Infinite scroll support
Local caching with localStorage

Smarter Search Logic

Optional Meilisearch backend — typo-tolerant, relevance-ranked, sub-50ms, with automatic local-DB fallback
Match by title + tags with bi-gram fallback
Search in SEO metadata (Yoast, Rank Math, AIOSEO, TSF, SEOPress)
Support ACF fields (e.g. company_name)
Tunable ranking (e.g. title > SEO > tags)
Search operators: +musthave, -mustnot

Cross-site Search

Query and merge results from other Init Live Search-powered sites
No CORS or auth config — just Site Name|https://example.com
Results auto-labeled by source (e.g. "Init Docs")

Productivity Built-In

Slash commands: /recent, /id, /fav, /product, /sku, /price, etc.
Full keyboard support: ↑ ↓ ← → Enter Esc
Quick search tooltip when selecting text
Voice search via SpeechRecognition (optional)

WooCommerce Ready

Filter by SKU, stock, price, sale status, brand, attribute, variation, coupon
Show prices, badges, "Add to Cart"
Slash commands: /product, /on-sale, /stock, /sku, /brand, /attribute, /variation, /coupon

Theming & Customization

Built-in style presets: style-full.css, style-topbar.css
Theme override support (style.css in theme)
Optionally disable all plugin CSS
Dark mode (dark, light, auto)

Built for Developers

PHP filters to override queries, ranking, result data
REST API endpoints: /search, /product, /id, etc.
JS events: ils:search-started, ils:results-loaded, etc.
WP-CLI support for Meilisearch reindexing
Complete developer docs + override guide

Optional Lightweight Analytics

Track query count, frequency, timestamps (no personal data)
Grouped view, export as CSV
Disabled by default, uses WordPress transients

Meilisearch Integration (Optional)

Init Live Search works great out of the box with zero setup — the built-in database search handles everything by default. If you want faster, typo-tolerant, relevance-ranked search at scale, connect your own Meilisearch instance in a few minutes.

Install and run Meilisearch yourself — self-hosted or via Meilisearch Cloud. This plugin doesn't host or manage a server for you.
Go to Settings → Init Live Search → Meilisearch, enter your Host URL, Index Name, and a search-only API key, then enable the integration.
Index your existing content:

   wp init-live-search meili-reindex

Done — search requests are now answered by Meilisearch. New, updated, and deleted posts stay in sync automatically.

Built for safety, not lock-in:

If Meilisearch is disabled, unconfigured, or fails to respond, the plugin silently falls back to local DB search — visitors never see a broken search box
The sensitive admin/indexing key can be set via the INIT_LIVE_SEARCH_MEILI_ADMIN_KEY constant in wp-config.php instead of the database
Turn it off any time — core search never depends on Meilisearch being present

Slash Command Examples

Command	Action
`/recent`	Show latest posts
`/id 123`	Load post by ID
`/product`	List products
`/sku ABC123`	Find by SKU
`/on-sale`	Show sale items
`/price 100 500`	Filter by price range (supports `sort`/`rsort`)
`/brand`	Filter by product brand
`/coupon`	Show active, usable coupons
`/fav`	Show saved favorites (localStorage)
`/random`	Jump to a random post

👉 Full Command Guide

Dev Tools You Get

JS events like ils:modal-opened, ils:results-loaded
PHP filters for SEO fields, fallback logic, ranking, and more
Theme override with custom style.css and related-posts templates
WP-CLI command for Meilisearch reindexing
Zero jQuery. Zero forced dependencies.

Installation

Install via WordPress.org or:

git clone https://github.com/brokensmile2103/init-live-search.git

Then activate and configure in Settings → Init Live Search.

Ways to trigger the modal:

Focus any <input name="s">
Press Ctrl + /
Triple-click anywhere
Click elements with data-ils
URL: ?modal=search&term=seo

Part of the Init Plugin Suite

Init Live Search is part of the Init Plugin Suite – a set of minimalist, performance-first tools for WordPress developers.

Thanks for reading. Got feedback or questions?
→ Project Page
→ GitHub