Best Violentmonkey Alternatives (2026)

If you rely on userscripts to customize web pages, automate repetitive tasks, or enhance browser functionality, you have likely encountered Violentmonkey. This open-source userscript manager provides a solid foundation for running custom JavaScript across websites. However, as we move through 2026, several alternatives have emerged that offer improved features, better performance, and enhanced developer experiences. This guide evaluates the top Violentmonkey alternatives for Chrome, helping you choose the right tool for your workflow.

Understanding Userscript Managers

Userscript managers enable you to inject custom JavaScript into web pages automatically. These tools power everything from simple UI tweaks to complex automation workflows. Violentmonkey has maintained popularity due to its open-source nature and straightforward approach, but the ecosystem has evolved significantly.

Modern alternatives address common problems including script synchronization across devices, better debugging capabilities, script packaging tools, and tighter integration with development workflows. For developers and power users, these improvements can dramatically improve productivity.

Before comparing tools, it helps to understand what a userscript manager actually does under the hood. When you install a script, the manager registers URL match patterns defined in the script’s metadata block. When Chrome loads a matching page, the extension injects the script into that page’s context at the specified @run-at phase (document-start, document-end, or document-idle). The script then has access to the page’s DOM and, through the manager’s grant APIs, capabilities like persistent storage, cross-origin HTTP requests, and clipboard access that ordinary page scripts cannot access.

The shift from Chrome’s Manifest V2 (MV2) to Manifest V3 (MV3) extension architecture has been the dominant technical story for userscript managers over the past two years. MV3 restricts the chrome.declarativeNetRequest API, removes the ability to eval arbitrary code strings, and imposes tighter content security policies. This has forced every major manager to rethink how they execute injected scripts, and the quality of each tool’s MV3 implementation is now a key differentiator.

Top Violentmonkey Alternatives in 2026

  1. Tampermonkey

Tampermonkey remains the most widely adopted userscript manager, and for good reason. It offers the most comprehensive script library support and works smoothly with scripts written for Greasemonkey 4.x syntax.

Key Features:

  • Cross-browser synchronization via cloud services
  • Built-in script editor with syntax highlighting
  • Script settings for granular control per-site
  • Automatic script updates with configurable intervals
// Tampermonkey script example with GM_* APIs
// ==UserScript==
// @name Page Title Modifier
// @namespace http://tampermonkey.net/
// @version 1.0
// @description Modify page titles for easier tab management
// @author Your Name
// @match https://*/*
// @grant GM_setValue
// @grant GM_getValue
// ==/UserScript==
(function() {
 'use strict';
 const prefix = GM_getValue('titlePrefix') || '[Work] ';
 document.title = prefix + document.title;
 console.log('Title modifier activated:', document.title);
})();

Tampermonkey excels in compatibility. If you find a script on userscript repositories, it almost certainly works with Tampermonkey out of the box. The extension supports both GM_* APIs and the newer GM.* namespace, providing flexibility for different script types.

For more complex scripts that make cross-origin HTTP requests, Tampermonkey’s GM_xmlhttpRequest implementation is the most battle-tested in the ecosystem. It correctly passes through cookies, custom headers, and response metadata in ways that some lighter alternatives get wrong:

// ==UserScript==
// @name Cross-Origin Data Fetcher
// @match https://dashboard.example.com/*
// @grant GM_xmlhttpRequest
// @grant GM_setValue
// @grant GM_getValue
// @connect api.externalservice.com
// ==/UserScript==
(function() {
 'use strict';
 const API_KEY = GM_getValue('apiKey', '');
 function fetchExternalData(endpoint) {
 return new Promise((resolve, reject) => {
 GM_xmlhttpRequest({
 method: 'GET',
 url: `https://api.externalservice.com/${endpoint}`,
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Accept': 'application/json',
 },
 onload: (response) => {
 if (response.status >= 200 && response.status < 300) {
 resolve(JSON.parse(response.responseText));
 } else {
 reject(new Error(`HTTP ${response.status}`));
 }
 },
 onerror: reject,
 });
 });
 }
 // Inject fetched data into the page
 fetchExternalData('v1/metrics').then(data => {
 const container = document.querySelector('#metrics-panel');
 if (container) {
 container.innerHTML = `<strong>External: ${data.value}</strong>`;
 }
 });
})();

Tampermonkey’s sync feature, which can push your full script library to Google Drive, OneDrive, or a custom URL endpoint, is particularly valuable for developers who work across multiple machines. Once configured, a new machine gets your entire script collection within seconds of installing the extension.

  1. ScriptCat

ScriptCat represents a newer generation of userscript managers built specifically for modern Chrome architectures. It offers improved security sandboxing and better memory management compared to older alternatives.

Key Features:

  • Native Chrome extension Manifest V3 support
  • Script dependency management
  • Built-in HTTP request interception
  • Advanced debugging tools
// ScriptCat example demonstrating advanced APIs
// ==UserScript==
// @name API Response Modifier
// @namespace scriptcat.org
// @version 1.0
// @match https://api.example.com/*
// @run-at document-start
// ==/UserScript==
// Intercept and modify API responses
cat.runtime.sendMessage('intercept', {
 url: 'https://api.example.com/data',
 callback: (response) => {
 response.modified = true;
 return response;
 }
});

ScriptCat’s strength lies in its developer-centric approach. The extension provides APIs specifically designed for building complex automation workflows, making it particularly attractive for developers building internal tools.

One area where ScriptCat stands out is its approach to script dependencies. Rather than bundling all code in a single file, ScriptCat lets you declare npm-style dependencies in the metadata block:

// ==UserScript==
// @name Data Processor
// @namespace scriptcat.org
// @version 2.0
// @match https://reports.company.com/*
// @require https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js
// @require https://cdn.jsdelivr.net/npm/[email protected]/dayjs.min.js
// @grant GM_setValue
// @grant GM_getValue
// ==/UserScript==
(function() {
 'use strict';
 // lodash and dayjs are available via @require
 const reports = JSON.parse(document.querySelector('#report-data')?.textContent || '[]');
 const grouped = _.groupBy(reports, r => dayjs(r.date).format('YYYY-MM'));
 const summary = _.mapValues(grouped, items => ({
 count: items.length,
 total: _.sumBy(items, 'amount'),
 avg: _.meanBy(items, 'amount'),
 }));
 GM_setValue('monthly_summary', JSON.stringify(summary));
 console.log('Summary cached:', summary);
})();

ScriptCat also ships with a built-in background task scheduler, which allows scripts to run on a timer rather than only when a matching page is open. a feature that opens up lightweight background automation that Tampermonkey does not natively support.

  1. Violentmonkey NG (Next Generation)

While the original Violentmonkey continues to exist, the NG version brings substantial improvements while maintaining compatibility with existing scripts.

Key Features:

  • Improved script matching with wildcard support
  • Enhanced storage for large script collections
  • Dark mode and custom themes
  • Export/import functionality for backup

The NG version addresses many of the limitations that caused users to seek alternatives. If you prefer sticking with Violentmonkey’s philosophy but need better performance, NG delivers exactly that.

Violentmonkey NG is the natural upgrade path if you already have a large library of scripts written for classic Violentmonkey. Migration requires no script changes. the metadata block format and grant APIs are fully backwards compatible. The NG version’s improved storage layer handles libraries of 200+ scripts without the sluggishness that some heavy Violentmonkey users reported in earlier versions.

The wildcard improvements in script matching are worth highlighting. Classic Violentmonkey required explicit URL patterns, which meant writing multiple @match lines to cover all variants of a URL. NG introduces @match-include patterns with more flexible glob syntax:

// ==UserScript==
// @name GitHub Enhancer
// @namespace violentmonkey.ng
// @version 1.5
// @match https://github.com/*
// @match https://gist.github.com/*
// @exclude https://github.com/login*
// @exclude https://github.com/signup*
// @run-at document-idle
// ==/UserScript==
(function() {
 'use strict';
 // Add line count to file headers in repository views
 document.querySelectorAll('.file-info .text-mono').forEach(el => {
 const lines = el.closest('.file')?.querySelectorAll('.blob-code').length;
 if (lines) {
 el.textContent += ` · ${lines.toLocaleString()} lines`;
 }
 });
})();
  1. Sleeky

Sleeky takes a minimalist approach, focusing on essential features without the bloat. It appeals to users who want a lightweight solution that starts fast and uses minimal memory.

Key Features:

  • Minimal resource footprint
  • Clean, distraction-free interface
  • Essential script management without complexity
  • Quick enable/disable toggles

This alternative suits users managing a small number of critical scripts rather than large collections.

Sleeky’s value proposition is clearest in memory-constrained environments. older hardware, Chromebooks, or heavily tab-laden browsing sessions where every megabyte counts. Its approach is to handle only the core injection pipeline and nothing else. There is no cloud sync, no built-in editor, no scheduling. You write scripts in your preferred external editor, paste them in, and Sleeky runs them.

For a focused use case. say, a single script that reformats your company’s internal dashboards. Sleeky adds no overhead at all.

Feature Comparison

Feature Tampermonkey ScriptCat Violentmonkey NG Sleeky
Manifest V3 Yes Yes Partial Yes
Cloud Sync Yes Limited No No
Built-in Editor Yes Yes Basic No
Script Updates Automatic Manual Automatic Manual
Memory Usage Medium Medium Low Very Low
Background Tasks No Yes No No
Dependency Management Via @require Native Via @require Via @require
Script Marketplace GreasyFork GreasyFork GreasyFork Manual only
Open Source Partial Yes Yes Yes
Debug Tools Basic Advanced Basic None

Choosing the Right Alternative

Your choice depends on your specific needs:

Choose Tampermonkey if you need maximum compatibility with existing scripts from repositories like GreasyFork. The extensive library support makes it the safest choice for users who rely on community scripts. The cloud sync feature is also the most mature in the category, making it the best choice if you work across multiple devices.

Choose ScriptCat if you are building custom automation solutions and need advanced APIs. Its developer-focused features enable sophisticated workflows not possible with simpler alternatives. particularly the background task scheduler and the advanced intercept APIs.

Choose Violentmonkey NG if you prefer the Violentmonkey experience but need better performance and modern Chrome support. It is also the right choice if you already have a large Violentmonkey script library and want zero migration friction.

Choose Sleeky if memory usage matters and you prefer a no-frills approach to userscript management. Ideal for users running a handful of focused scripts on lower-powered hardware.

Migration Tips

When switching between managers, keep these points in mind:

  1. Export your scripts from the current manager before uninstalling
  2. Check script syntax. some managers support different API sets
  3. Test critical scripts in a new tab before relying on them
  4. Update script declarations. specifically the @match and @grant tags
// Converting GM_xmlhttpRequest to fetch in modern contexts
// Old approach
GM_xmlhttpRequest({
 url: 'https://api.example.com/data',
 onload: (response) => {
 console.log(JSON.parse(response.responseText));
 }
});
// Modern approach using native fetch
async function fetchData() {
 const response = await fetch('https://api.example.com/data');
 const data = await response.json();
 console.log(data);
}

When migrating a large script library from Tampermonkey to ScriptCat or Violentmonkey NG, the most common issue is scripts that use undocumented Tampermonkey-specific behavior. Before migrating, audit your scripts for GM_info.scriptHandler checks. scripts that conditionally execute code based on which manager is running may need adjustments. Also check any scripts that use GM_registerMenuCommand, as the UI implementation varies between managers.

A reliable migration checklist:

  1. Export all scripts from the source manager as a .zip backup
  2. In the destination manager, install scripts one at a time rather than bulk importing
  3. Visit a few of the target pages for each script and confirm the expected behavior
  4. Check the browser console for any GM_* API errors. these point to API name mismatches
  5. For scripts that make network requests, verify the @connect directives match what the script actually calls
  6. Only uninstall the source manager after running both in parallel for at least a week

Manifest V3 Impact on Userscript Managers

The Chrome extension platform’s shift to MV3 has had uneven effects across the userscript manager ecosystem. The core challenge is that MV3 eliminated the chrome.tabs.executeScript API that MV2 extensions used to inject arbitrary code. MV3 replacements require content scripts to be declared statically in the manifest, which conflicts with the fundamentally dynamic nature of userscript injection.

Each manager has solved this differently:

  • Tampermonkey uses a hybrid approach: a statically declared content script that acts as a loader, which then dynamically evaluates script content in a sandboxed context
  • ScriptCat built its entire architecture around MV3 from the start, using the MAIN world injection target available in Chrome 111+ to run scripts in the page’s JavaScript context
  • Violentmonkey NG uses the userScripts API introduced in Chrome 120, which explicitly supports dynamic script injection for userscript managers
  • Sleeky takes the userScripts API approach as well, benefiting from its simpler architecture

The practical implication: if you are running Chrome 120 or later (which is essentially everyone as of 2026), the userScripts API-based managers (Violentmonkey NG, Sleeky) have the cleanest implementation. If you are in a managed enterprise environment pinned to an older Chrome version, Tampermonkey’s hybrid approach is the most compatible.

Writing Your First Custom Script

If you are new to userscripts, the fastest way to get productive is to pick a page you use daily and solve one small annoyance. Here is a complete, well-commented example that works in all four managers:

// ==UserScript==
// @name Auto-Expand Collapsed Comments
// @namespace your-namespace
// @version 1.0
// @description Automatically expand collapsed comment threads
// @match https://news.ycombinator.com/*
// @match https://old.reddit.com/*
// @run-at document-idle
// @grant GM_setValue
// @grant GM_getValue
// ==/UserScript==
(function() {
 'use strict';
 // Read user preference from persistent storage
 const autoExpand = GM_getValue('autoExpand', true);
 if (!autoExpand) return;
 function expandCollapsed() {
 // Hacker News collapsed comments have class 'coll'
 document.querySelectorAll('.coll').forEach(el => {
 const toggle = el.querySelector('.togg');
 if (toggle) toggle.click();
 });
 // Old Reddit collapsed comments
 document.querySelectorAll('.comment.collapsed').forEach(el => {
 const toggle = el.querySelector('.expand');
 if (toggle) toggle.click();
 });
 }
 // Run immediately for existing content
 expandCollapsed();
 // Watch for dynamically loaded content
 const observer = new MutationObserver(() => expandCollapsed());
 observer.observe(document.body, { childList: true, subtree: true });
})();

This script demonstrates the essential patterns: metadata block, persistent storage, DOM manipulation, and a MutationObserver for dynamic pages. From here, the same structure scales to far more sophisticated automation.

Conclusion

The userscript ecosystem in 2026 offers solid alternatives to Violentmonkey, each with distinct strengths. Tampermonkey remains the gold standard for script library compatibility, while ScriptCat provides superior developer tools. Violentmonkey NG revitalizes the original project, and Sleeky delivers lightweight efficiency.

For most developers and power users, Tampermonkey or ScriptCat will provide the best experience. The key is evaluating your specific requirements. whether that is script compatibility, development features, background task support, or resource efficiency. and selecting the manager that aligns with your workflow. The MV3 transition has pushed all four managers to ship more thoughtful architectures, and any of them is a solid choice for a well-maintained script library in 2026.

I've tried them all. Claude Code wins — but only if you set it up right. The gap isn't the tool. It's the CLAUDE.md, the prompts, the workflow. I run 5 Claude Max subscriptions in parallel with autonomous agent fleets. These are my actual configs — the ones that let a solo dev outproduce a small team. **[See the full setup →](https://zovo.one/lifetime?utm_source=ccg&utm_medium=cta-compare&utm_campaign=violentmonkey-alternative-chrome-extension-2026)** $99. Once. Everything I use to ship.

Related Reading

Built by theluckystrike. More at zovo.one