Hubbry Logo
GreasemonkeyGreasemonkeyMain
Open search
Greasemonkey
Community hub
Greasemonkey
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Greasemonkey
Greasemonkey
Greasemonkey
View on Wikipedia
from Wikipedia

Greasemonkey
Original authorAaron Boodman
DevelopersAnthony Lieuallen, Johan Sundström,[1] 13 more[2]
Initial release28 March 2005; 20 years ago (2005-03-28)[3]
Stable release
4.13 / 5 August 2024; 18 months ago (2024-08-05)
Written inJavaScript, XUL, CSS
Operating systemCross-platform
Available inEnglish
TypeMozilla extension
LicenseMIT License
Websitewww.greasespot.net
Repository

Greasemonkey is a userscript manager made available as a Mozilla Firefox extension. It enables users to install scripts that make on-the-fly changes to web page content after or before the page is loaded in the browser (also known as augmented browsing).

The changes made to the web pages are executed every time the page is viewed, making them effectively permanent for the user running the script.

Greasemonkey can be used for customizing page appearance, adding new functions to web pages (for example, embedding price comparisons within shopping sites), fixing rendering bugs, combining data from multiple web pages, and numerous other purposes.

History

[edit]

The Greasemonkey project began 28 November 2004, written by Aaron Boodman.[4][5][6] Boodman was inspired to write Greasemonkey after looking at a Firefox extension designed to clean up the interface of AllMusic,[7] written by Adrian Holovaty, who later became a userscript developer. By May 2005, there were approximately 60 general and 115 site-specific userscripts distributed for Greasemonkey.[7] In July 2005, serious vulnerabilities were found in Greasemonkey by Mark Pilgrim,[8][9] and fixed in the 3.5 version of Greasemonkey.[10] During this time, a Greasemonkey compiler was also developed for converting a userscript into a standalone Firefox extension.[11] Greasemonkey was initially met with complaints by publishers for its ability to block ads.[12] However, this criticism shifted its focus to other addons starting with the 2006 release of Adblock Plus.

Userscripts.org

[edit]

To accommodate the growing number of scripts, userscripts.org was founded by Britt Selvitelle and other members of the Greasemonkey community in late 2005. Userscripts.org was open sourced in 2007 but the site later moved away from this code base.[13] As the main script repository listed on Greasemonkey's official site, userscripts.org accumulated thousands of scripts per year.

In 2010, the last known admin Jesse Andrews posted that the site was in maintenance mode due to lack of time and asked for a new maintainer to volunteer.[14] Nevertheless, he remained the sole admin of the site until a discussion about install counts began on 1 April 2013.[15] Prior to this, many of the "most popular scripts" as listed by the site had nominal install counts of zero. Over the following year spam scripts became more common, server downtime increased and the install count bug remained.[16] With no further communication by Andrews, userscript writers described the site as neglected and the official Greasemonkey site removed its front page link.[17][18] In response, script writers and other developers began working on the fork "openuserjs.org",[19][20] and later greasyfork.org,[21] as an immediate replacement.[22]

In May 2014, userscripts.org became inaccessible on port 80, prompting users to access it on port 8080 instead.[16] In August 2014, the site was shut down completely. Most of its scripts were backed up to the static mirror userscripts-mirror.org where they can now be found.[16]

Technical details

[edit]

Greasemonkey user scripts are written in JavaScript and manipulate the contents of a web page using the Document Object Model interface. Scripts are generally written to be either page-specific or domain-specific (applying to all pages within a domain) but may also be tagged to apply to all domains for global browser enhancements. Users of Greasemonkey can write or download scripts and save them to their own personal library. When users visit a website matching a script in their personal script library, Greasemonkey invokes the relevant scripts.

Greasemonkey scripts can modify a webpage in any way that JavaScript allows, with certain Greasemonkey security restrictions. Scripts can also access other web pages and web services via a non-domain-restricted XMLHTTP request, allowing external content to be merged with the original page content.

Scripts are named somename.user.js, and Greasemonkey offers to install any such script when a URL ending in that suffix is requested. Greasemonkey scripts contain metadata which specifies the name of the script, a description, resources required by the script, a namespace URL used to differentiate identically named scripts, and URL patterns for which the script is intended to be invoked or not.

Writing a Greasemonkey script is similar to writing JavaScript for a web page, with some additional allowances such as cross-site XMLHttpRequests. Compared to writing a full-fledged Firefox extension, user scripting is a very modest step up in complexity from basic web programming. However, Greasemonkey scripts are limited due to security restrictions imposed by Mozilla's XPCNativeWrappers[23] For example, Greasemonkey scripts do not have access to many of Firefox's components, such as the download manager, I/O processes or its main toolbars. Additionally, Greasemonkey scripts run per instance of a matching webpage. Because of this, managing lists of items globally is difficult. However, script writers have been using cookies, and Greasemonkey even offers APIs such as GM_getValue and GM_setValue to overcome this.

User scripts

[edit]

File hosting servers for Greasemonkey require that the URLs for the scripts end with .user.js and not with a MIME type like text/html. Support for HTTPS will meet with[clarification needed] Greasemonkey's built in update checker. As of July 2019, the Greasemonkey project lists three recommended user script hostings:[24]

  • Gist, a pastebin service operated by GitHub where simple files are hosted. Files can be pasted into a web form and saved. HTTPS is used by default. Files may follow the naming scheme with the ".user.js" suffix for the URL serving as an install link.
  • Greasy Fork, a site created by the maintainer of userstyles.org.[21]
  • OpenUserJS.org, a site that started as a fork for the deprecated script repository userscripts.org.[19][20]

Compatibility

[edit]

Greasemonkey is available for Firefox, Flock, and GNOME Web (formerly called Epiphany). The Greasemonkey extension for Web is part of the Web extensions package. However, this extension is not fully compatible as of release 2.15.1, since some Greasemonkey API functions (e.g. GM_getValue) are unsupported. There are also custom versions for SeaMonkey,[25][26] Songbird,[27] Pale Moon,[28] qutebrowser,[29] and Falkon browser.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Greasemonkey

View on Grokipedia
from Grokipedia
Greasemonkey is a extension for the Mozilla web browser that enables users to install and run small pieces of code, known as user scripts, to customize the appearance, behavior, and functionality of web pages on the fly. Developed by Aaron Boodman and first released in 2005, it was inspired by the need to simplify the creation of extensions, making it as straightforward as writing (DHTML). Greasemonkey allows users to either write their own scripts or install those created by the , which can perform tasks such as removing advertisements, enhancing user interfaces, automating repetitive actions, or integrating additional features into websites like platforms or sites. Key features include script management tools for enabling, disabling, and editing scripts; support for metadata headers in scripts to specify matching URLs; and integration with Firefox's extension framework for secure execution within sandboxes. Over its nearly two decades of development, Greasemonkey has undergone significant evolution, with early versions facing security challenges—such as a 2005 vulnerability allowing file access—that were promptly addressed by the community. The project, maintained through open-source contributions on and community forums, saw a resurgence after a development hiatus during Firefox's major extension API changes in the mid-2010s. Its latest release, version 4.13 as of August 2024, introduced enhancements like improved Android support for functions such as opening tabs. Widely credited with popularizing the userscript ecosystem, Greasemonkey has influenced the creation of cross-browser alternatives like and Violentmonkey, extending similar customization capabilities to Chrome, Edge, and other browsers. Despite competition and browser evolution, it remains a cornerstone for power users and developers seeking granular control over their browsing experience without relying on site owners' updates.

History

Origins and early development

Greasemonkey was created by Aaron Boodman on November 28, 2004, as a extension for the Mozilla Firefox browser. The extension was designed to enable users to install and run customizable code that modifies web pages in real time, allowing alterations to content, structure, and behavior without changing the underlying website code. Boodman's initial motivation stemmed from the growing need for user-driven web customization in the early days of , where users sought ways to personalize their browsing experience amid the static nature of many websites at the time. He aimed to lower the barrier for non-developers to implement on-the-fly enhancements, such as removing ads, reformatting layouts, or adding interactive features, thereby empowering individuals to augment the web to their preferences. Shortly after its inception, Boodman was joined by early collaborators Anthony Lieuallen and Johan Sundström, who contributed to maintenance and development as the project gained traction. The first public prototype was released on , 2005, marking the extension's broader availability. By May 2005, the ecosystem had expanded rapidly, with more than 100 userscripts available, including both general-purpose tools and site-specific modifications. To support the burgeoning collection of scripts, Userscripts.org was founded in late 2005 by Britt Selvitelle along with other community members, establishing it as the central repository for sharing and discovering Greasemonkey-compatible code.

Key milestones and versions

Greasemonkey's early development in 2005 was marked by rapid iterations to address security concerns, with version 0.3.5 released on July 19, 2005, specifically to fix a critical vulnerability that allowed malicious scripts to exploit browser privileges. This update removed vulnerable features and urged all users to upgrade immediately to mitigate potential exploits. Subsequent releases, such as version 0.5.1 on August 25, 2005, further hardened security by patching script issues. A significant external challenge occurred in May 2014 when Userscripts.org, the primary repository for Greasemonkey scripts, was shut down due to severe security breaches and hacking incidents, prompting the community to migrate hosting to alternative platforms like Greasy Fork and OpenUserJS.org. This event disrupted script distribution but spurred the growth of decentralized hosting solutions within the userscript ecosystem. Development faced another pivot with Firefox's transition to the in , which deprecated legacy extensions; Greasemonkey's team restarted active work to adapt, culminating in version 4.0's release on November 2, . This major rewrite ensured compatibility with 57 and later but initially omitted some legacy features like certain API behaviors, with promises of gradual restorations in subsequent updates. Between and 2019, ongoing adaptations to Firefox's evolving extension policies, including stricter sandboxing and API restrictions, maintained Greasemonkey's viability amid browser changes. The project continues under the , with maintenance handled by over 13 developers following the initial core team, fostering community-driven improvements. The latest stable release, version 4.13 on August 5, 2024, supports 58.0 and later versions, including Android, while adding features like enhanced tab opening APIs and fixing script update mechanisms.

Features

Core capabilities

Greasemonkey enables users to install and execute userscripts that modify web pages after they load, allowing alterations to the page's display, behavior, or content. These scripts run automatically on matching URLs, injecting custom code to enhance or customize the browsing experience without altering the original website. At its core, Greasemonkey supports on-the-fly changes through userscripts, such as adding new features like , UI enhancements, automating user interactions, or integrating external sources into the page. For instance, scripts can hide unwanted elements, rearrange layouts, or fetch and display additional information from APIs, all executed dynamically as the page renders. Userscripts leverage (DOM) manipulation to inject or modify , CSS, and elements in real time. This includes accessing and altering the page's document object via wrapped interfaces, enabling precise changes like inserting new buttons or styling overrides while the page is active. To ensure security, Greasemonkey employs a permissions model where scripts operate in isolated sandboxed contexts, granting access to the host page's DOM but restricting direct cross-origin requests unless explicitly permitted through enhanced APIs like GM.xmlHttpRequest. This isolation uses XPCNativeWrapper to prevent unauthorized interactions, balancing functionality with protection against malicious code. Common applications include customizing feeds by filtering content or adding previews, enhancing results with additional annotations, and implementing site-specific keyboard shortcuts for quicker navigation. These capabilities make Greasemonkey a powerful tool for personalized web augmentation.

Script management tools

Greasemonkey provides a centralized for managing installed user scripts, accessible through the Monkey Menu icon in the Firefox . This interface lists all scripts alphabetically by name, with enabled scripts displayed in full color and disabled ones in gray for quick visual identification. Users can view script details, including metadata such as @name, , and applicable domains via @include, @exclude, or directives. From here, scripts can be enabled or disabled individually by toggling checkboxes or selecting options in the detail view, allowing precise control over which scripts run on specific pages. Automatic update checking is a key feature for maintaining script currency, triggered for scripts containing a @version directive in their metadata block. Greasemonkey periodically—by default every seven days—fetches the script from its original installation URL or a specified @updateURL if provided, comparing the remote @version against the installed one using semantic versioning rules. If a newer version is detected, Greasemonkey prompts the user for installation, automatically applying the update upon confirmation to ensure scripts remain functional and secure. Users can also manually initiate checks or toggle auto-updates globally via the dashboard's options. A global toggle for script activation is available directly in the Monkey Menu, positioned at the top for easy access. When activated, this option disables all user scripts across the browser session, providing a quick way to troubleshoot issues or pause customizations without uninstalling. Re-enabling restores full functionality, with the monkey in the serving as the primary control point for this feature. Script editing is supported through an embedded editor integrated into the . Selecting a script and choosing the edit option opens its in a multi-tab interface, where the main script appears in the first tab and any @require or @resource files in subsequent tabs. Changes can be saved directly with Ctrl+S or the save , applying modifications immediately upon browser reload for testing purposes; however, live reloading without restart is not natively supported in version 4.0 due to WebExtension limitations. External editors are not integrated, requiring manual file management for advanced workflows. Greasemonkey executes scripts in the order displayed in the management interface, which sorts them alphabetically by @name by default. This order determines the sequence of execution, with earlier scripts running first and potentially affecting the DOM for later ones. To mitigate conflicts, users can adjust the execution order directly via right-click context menu options such as 'Execute first,' 'Execute sooner,' 'Execute later,' or 'Execute last'; no drag-and-drop reordering is available.

Technical aspects

Implementation and execution

Greasemonkey is implemented primarily in , leveraging the for its core functionality in modern versions, while legacy versions prior to 57 utilized for user interface elements and CSS for styling. Scripts managed by Greasemonkey execute at specific timings controlled by the @run-at metadata directive, with document-end as the default, occurring after the document's is parsed but before external resources like images fully load, at which point document.readyState is "interactive". Alternative timings include document-start, which injects the script early during page loading when document.readyState is "loading", and document-idle, which delays execution until after the page and all its resources, including scripts, have fully loaded. These options allow scripts to intervene at precise points in the page lifecycle, though support for document-start and document-idle is limited in Greasemonkey 4.x, with document-end being the only fully guaranteed timing. User scripts in Greasemonkey 4.x are injected as content scripts using the WebExtensions API, executing in an isolated context (isolated world) separate from the page's JavaScript environment. This isolation prevents direct access to the page's variables and functions while allowing full read/write access to the DOM via the page's window and document objects. Scripts are executed within an to avoid global pollution, unless the @unwrap directive is specified in the metadata, which injects the script without the wrapper for compatibility purposes. The extension provides access to enhanced Greasemonkey APIs for privileged operations. Cross-site XMLHttpRequest (XHR) operations are supported through the GM.xmlHttpRequest API, which bypasses same-origin policy restrictions, allowing scripts to make requests to any domain provided the necessary permissions are granted via the @grant metadata directive, such as @grant GM.xmlHttpRequest. When @grant none is used, scripts rely on the standard XMLHttpRequest object, which adheres to CORS policies and may restrict cross-site access unless the target server permits it, thereby preventing unauthorized data exfiltration. This permission model ensures controlled access to network resources without compromising browser security. Error handling in Greasemonkey directs script failures to the browser's console for logging, where developers can inspect errors, warnings, and custom logs via GM_log or console.log, without causing the extension to crash or halt overall functionality. Users can configure scripts to ignore non-critical errors or enable modes to isolate issues, maintaining stability even if individual scripts encounter runtime exceptions.

Metadata and APIs

Greasemonkey userscripts begin with a required metadata block enclosed in // ==UserScript== and // ==/UserScript== comments, which provides essential information for the extension to identify, install, and execute the script. The block must include the // @name directive to specify a unique script name within its , the // @namespace directive to define a such as a URL for avoiding conflicts, and the // @version directive to indicate the script's version number for update management. Additionally, matching directives such as // @include, // @match, or // @exclude are used to define URL patterns where the script should or should not run, using wildcard or glob-like matching to specify execution scope. Optional metadata headers enhance script discoverability and management without affecting core functionality. The // @description directive provides a brief summary of the script's purpose, while the // @author directive credits the creator. For more precise URL targeting, the // @match directive employs glob-like patterns, such as https://www.example.com/*, to determine applicability on specific pages. Upon installation, the Greasemonkey extension parses the metadata block at the script's top level, validating required headers and ignoring unrecognized keys to ensure integrity. It uses the combined name and for uniqueness, version for automatic updates, and URL patterns from include, exclude, or match directives to set execution scope and permissions, processing this information to manage script activation without executing the block's content. Greasemonkey provides a suite of native APIs prefixed with GM_ to extend userscript capabilities beyond standard JavaScript, focusing on secure and persistent operations. The GM_xmlhttpRequest function enables cross-domain HTTP requests, bypassing same-origin policy restrictions by accepting parameters like method, URL, headers, and callbacks for onload events. For data persistence, GM.setValue(key, value) asynchronously stores key-value pairs across sessions (returns a Promise), while GM.getValue(key, defaultValue?) asynchronously retrieves them (also returns a Promise). These support various data types, with the key as a string. For compatibility with legacy scripts, polyfills may be used, but new scripts should handle the asynchronous nature using async/await or .then(). The GM_addStyle function injects custom CSS into the page by passing a string of styles, such as "body { background-color: yellow; }", to modify appearance dynamically. These GM_ APIs maintain compatibility with similar functions in other userscript managers like Violentmonkey and , allowing scripts to function across platforms with minimal adjustments, though Greasemonkey emphasizes its native implementations for environments.

Usage and installation

Browser compatibility

Greasemonkey primarily supports Mozilla versions 57 and later, functioning as a WebExtensions-compatible add-on that allows users to manage and execute userscripts across web pages. This compatibility ensures seamless integration with modern Firefox features, including enhanced security and performance optimizations introduced in the . Legacy versions of Greasemonkey, based on the framework, remain compatible with 4 through 56, enabling continued use on older installations that do not support WebExtensions. Community-maintained ports extend this legacy support to other Mozilla-derived browsers, such as and , where adapted versions preserve XUL-based functionality for users preferring these forks. Additional ports exist for and , allowing management in these QtWebEngine and keyboard-centric browsers, respectively, though with varying degrees of feature parity to the implementation. However, it lacks native support for or , necessitating alternatives like for userscript functionality in those environments. As a browser extension, Greasemonkey is platform-independent, running on Windows, macOS, , and Android through compatible installations. In 2024, updates to Greasemonkey ensured alignment with Firefox's ongoing WebExtensions evolution.

Setup and basic usage

To install Greasemonkey, users should visit the official Add-ons page and click the "Add to " button, which downloads and prompts for installation of the extension. On Android, installation follows the same process via the browser's add-ons menu. Once installed, Greasemonkey appears in the browser's toolbar as a monkey icon; if not visible, access it via the Add-ons Manager at about:addons to enable it. During or after installation, requests permissions for Greasemonkey to access and modify web content on all sites, which must be granted to allow script injection; denying this prevents functionality. For the first script, locate a user script file ending in .user.js—either by downloading it or navigating directly to a hosted —and open it in , triggering Greasemonkey's installation dialog. The dialog displays the script's metadata, including its name, description, author, version, and rules like @include or @exclude patterns that define target websites. Review this information, wait for a brief security delay that enables the "Install" button, then click it to add the script; to verify execution, navigate to a matching site (e.g., one specified in @include), where the script should apply its modifications automatically. In basic usage, open the Greasemonkey dashboard by clicking the toolbar icon (Monkey Menu), which lists all installed scripts with options to enable, disable, or edit them. Browse to a target website; active scripts run on load, and you can toggle them individually via the dashboard if needed to test effects. To monitor output or errors, open the Browser Console (Ctrl+Shift+J or Cmd+Shift+J on macOS) and check for script logs or issues. Common setup issues include the extension not being enabled, resolved by visiting about:addons, selecting Extensions, and toggling Greasemonkey on, followed by a browser restart. If a script fails to run, refresh the page (Ctrl+R or Cmd+R) after installation or toggling, as changes may not apply immediately. Mismatches in @include patterns—such as incorrect wildcards—can prevent execution; inspect these in the installation dialog or dashboard to ensure they align with the site's domain and path. Greasemonkey incorporates security prompts during script installation to mitigate risks from malicious , requiring explicit user confirmation via the dialog and imposing a short delay before the "Install" option activates, giving time to review metadata and abort if suspicious. This process ensures users intentionally approve each addition, preventing drive-by installations.

Ecosystem

Script repositories and community

Following the shutdown of Userscripts.org in 2014, which had served as the primary repository for Greasemonkey scripts since 2005, the community shifted to new platforms to host and share user scripts. Greasy Fork, launched in March 2014 by Jason Barnabe—the developer behind Userstyles.org—emerged as a leading site focused on vetted, moderated scripts to ensure quality and security. OpenUserJS.org, initiated around the same time as an open-source alternative, provides a platform for hosting freely modifiable scripts, emphasizing collaborative development. Additionally, GitHub Gists offer a lightweight option for developers to share individual scripts directly, often integrated with for easy updates. Community efforts played a crucial role in preserving content from Userscripts.org after its closure, including the creation of static mirrors like userscripts-mirror.org to archive the site's library. Many scripts were manually migrated to Greasy Fork and OpenUserJS.org by users and developers, safeguarding a vast collection that included thousands of entries from the original repository and enabling continued access without significant loss. This transition highlighted the community's commitment to maintaining the ecosystem, with tools and discussions facilitating bulk imports and updates. The Greasemonkey community revolves around dedicated online resources for support and collaboration. The Greasespot.net serves as the central hub for documentation, offering guides on script installation, , and best practices maintained by contributors. Stack Overflow's [greasemonkey] tag provides technical support through Q&A, where developers address implementation issues and share code snippets. On Reddit, the r/Greasemonkey subreddit fosters discussions on script ideas, bug fixes, and customizations, with active threads on compatibility and new features. Script discovery is streamlined through searchable catalogs on these platforms, featuring user ratings, installation metrics, and update frequencies to help evaluate reliability. Greasy Fork, for instance, displays daily installs (e.g., popular scripts garnering thousands per day), total installs (often exceeding 100,000 for widely used ones), and star-based ratings, alongside daily updates from contributors. OpenUserJS.org similarly sorts scripts by installs and ratings, promoting open-source contributions where users can fork and improve existing code via GitHub integration. This emphasis on transparency and community input encourages verifiable, high-quality scripts. As of 2025, Greasy Fork and OpenUserJS.org collectively host tens of thousands of active Greasemonkey-compatible scripts, with ongoing developer engagement evident in regular updates, new submissions, and forum activity. These platforms sustain a vibrant , where open-source ethos drives innovation and user participation, including adaptations to browser changes like the full rollout of Manifest V3 in mid-2025.

Alternatives and forks

Several userscript managers serve as popular alternatives to Greasemonkey, offering similar functionality for customizing web pages through scripts but with expanded browser support and additional features. , one of the most widely used options, is compatible with Chrome, , , Next, and , providing broader support including a built-in editor, syntax checking, and a for older Greasemonkey scripts (version 3.x and below). It also includes mobile compatibility via Android support through Microsoft Edge, enabling users to run scripts on portable devices. Another notable alternative is Violentmonkey, an open-source manager that works across multiple browsers supporting WebExtensions, such as and Brave, with a focus on simplicity and no advertisements or automatic page modifications. Forks and ports of Greasemonkey extend its legacy to niche browsers while preserving core features. Violentmonkey provides high API compatibility with both Greasemonkey and scripts, emphasizing minimal resource usage. For legacy browsers, dedicated ports maintain Greasemonkey's functionality: the Greasemonkey Port project, hosted on , is a fork specifically for , originally developed by Aaron Boodman and maintained by contributors like Marti and Ratty, allowing script installation, management, and automatic updates within SeaMonkey's add-ons system. Similarly, a forked version of Greasemonkey is available for through its add-ons site, based on releases, which supports userscript management tailored to Pale Moon's XUL-based architecture and retains features like script enabling/disabling and execution ordering. Key differences among these alternatives highlight trade-offs in features and design. stands out with cloud synchronization across devices using its built-in sync feature, along with extended storage APIs for more robust script data handling, making it suitable for users needing seamless multi-browser and multi-device workflows. In contrast, Violentmonkey prioritizes speed and minimalism through its simple interface and support for external editors, avoiding heavy frameworks while offering cloud sync via third-party services like , , [Google Drive](/page/Google Drive), or . These ports for and , however, focus on maintaining legacy compatibility without adding new features, ensuring stability for users on older browser engines but lacking modern enhancements like mobile support. Alternatives emerged primarily due to Greasemonkey's exclusive focus on , which limited its appeal amid the rise of Chromium-based browsers, and the need for enhanced features following major browser updates around that disrupted extension ecosystems. Users seeking Chromium support or advanced capabilities, such as broader access and synchronization, often turned to or Violentmonkey to avoid compatibility issues with non-Firefox environments. As of 2025, adoption trends reflect browser market dynamics, with boasting over 10 million users on the alone, driven by Chrome's dominance and its versatile cross-browser and mobile features. Greasemonkey, while still preferred by Firefox purists for its open-source purity and tight integration, has a smaller user base, evidenced by fewer reviews on the Firefox Add-ons site compared to its alternatives. Violentmonkey appeals to open-source enthusiasts with its lightweight design but sees moderate adoption, particularly on and Brave; while Chrome's Manifest V3 transition initially impacted its availability, updated versions now support MV3 as of 2025.

References

  1. https://addons.mozilla.org/en-US/firefox/addon/greasemonkey/
  2. https://github.com/greasemonkey/greasemonkey
  3. https://www.stevesouders.com/blog/2010/05/18/cross-browser-greasemonkey-scripts/
  4. https://wiki.greasespot.net/Greasemonkey
  5. https://www.infoworld.com/article/2219470/greasemonkey-in-crisis.html
  6. https://www.wikihow.com/Use-Greasemonkey
  7. https://www.greasespot.net/
  8. https://simonwillison.net/2005/Jul/20/vulnerability/
  9. https://news.ycombinator.com/item?id=26057106
  10. https://www.crunchbase.com/organization/greasemonkey
  11. https://bookstack.kb.ucla.edu/books/internet-and-web-browsers/page/greasemonkey-and-firefox
  12. https://www.computerhope.com/jargon/g/greasemonkey.htm
  13. https://blog.chromium.org/2010/02/40000-more-extensions.html
  14. https://informationr.net/ir/11-3/paper257.html
  15. https://www.wired.com/2005/05/firefox-users-monkey-with-the-web/
  16. https://github.com/OpenUserJs/OpenUserJS.org/wiki/Greasemonkey-for-Firefox
  17. https://sourceforge.net/p/greasemonkey/wiki/Version_history/
  18. https://wellfound.com/p/bs
  19. http://www.greasespot.net/2005/07/mandatory-greasemonkey-update.html
  20. http://www.greasespot.net/2005/08/greasemonkey-051-final.html
  21. https://www.ghacks.net/2014/05/09/userscripts-org-good-alternatives/
  22. https://github.com/greasemonkey/greasemonkey/issues/1884
  23. http://www.greasespot.net/2017/09/greasemonkey-4-announcement.html
  24. https://wiki.greasespot.net/Version_history
  25. https://addons.mozilla.org/en-US/firefox/addon/greasemonkey/versions/
  26. https://wiki.greasespot.net/Greasemonkey_Manual
  27. https://wiki.greasespot.net/User_script
  28. https://wiki.greasespot.net/Greasemonkey_Manual:Environment
  29. https://wiki.greasespot.net/Greasemonkey_Manual:APIs
  30. https://wiki.greasespot.net/Greasemonkey_Manual:Monkey_Menu
  31. https://wiki.greasespot.net/Metadata_Block
  32. https://stackoverflow.com/questions/20501091/greasemonkey-how-often-script-check-updates-with-updateurl
  33. https://wiki.greasespot.net/Greasemonkey_Manual:Editing
  34. https://github.com/greasemonkey/greasemonkey/issues/2679
  35. https://www.ghacks.net/2017/09/21/greasemonkey-4-firefox-57-compatibility/
  36. https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts
  37. https://wiki.greasespot.net/GM.xmlHttpRequest
  38. https://wiki.greasespot.net/Troubleshooting_%28Users%29
  39. https://wiki.greasespot.net/Greasemonkey_Manual:API
  40. https://wiki.greasespot.net/GM.setValue
  41. https://www.greasespot.net/2017/09/greasemonkey-4-for-script-authors.html
  42. https://sourceforge.net/projects/gmport/
  43. https://openuserjs.org/about/Greasemonkey-Port-for-SeaMonkey
  44. https://www.mturkcrowd.com/threads/which-browsers-can-you-run-userscripts-in-and-how.153/
  45. https://blog.mozilla.org/addons/2024/03/13/manifest-v3-manifest-v2-march-2024-update/
  46. https://wiki.greasespot.net/Greasemonkey_Manual:Installing_Scripts
  47. https://www.ghacks.net/2014/03/29/greasy-fork-userscript-org-alternative-creator-userstyles-org/
  48. https://askubuntu.com/questions/962685/how-to-load-greasemonkey-scripts-directly-from-a-github-gist-or-repo
  49. https://wiki.greasespot.net/User_Script_Hosting
  50. https://wiki.greasespot.net/
  51. https://stackoverflow.com/questions/tagged/greasemonkey
  52. https://www.reddit.com/r/GreaseMonkey/
  53. https://greasyfork.org/en/scripts
  54. https://openuserjs.org/
  55. https://www.ituonline.com/tech-definitions/what-is-grease-monkey-user-scripting/
  56. https://vivaldi.com/blog/manifest-v3-update-vivaldi-is-future-proofed-with-its-built-in-functionality/
  57. https://www.tampermonkey.net/
  58. https://violentmonkey.github.io/
  59. https://addons.palemoon.org/extensions/tools-and-utilities/
  60. https://github.com/janekptacijarabaci/greasemonkey/releases/latest
  61. https://alternativeto.net/software/greasemonkey/
  62. https://chromewebstore.google.com/detail/tampermonkey/dhdgffkkebhmkfjojejmpbldmpobfkfo
  63. https://addons.mozilla.org/en-US/firefox/addon/violentmonkey/
Add your contribution
Related Hubs
User Avatar
No comments yet.