Userscripts Are Fun and Are Still Very Much Relevant (opens in new tab)

Given the increasingly hostile nature of websites, along with the tendency to remove user control, userscripts are not just still relevant but more relevant than ever.

Here's some that I like:

https://greasyfork.org/en/scripts/10096-general-url-cleaner

https://greasyfork.org/fr/scripts/19210-google-direct-links-...

https://github.com/ParticleCore/Iridium

> We could create a browser extension, but that means developing one for all major browsers.

Personally, I use most of the extensions I've written in userscript form via Greasemonkey for the convenience of being able to drop straight into editing and testing it when I spot something which could be added or needs to be fixed.

If your userscript doesn't depend on any APIs provided by the userscript manager you're using, you can package it up as a WebExtension by adding a manifest.json:

    {
      "manifest_version": 2,
      "name": "Your Userscript",
      "version": "1.0",
      "content_scripts": [
        {
          "matches": [
            "https://example.com/*",
          ],
          "js": [
            "./your-userscript.user.js"
          ]
        }
      ]
    }

Once you've dropped a manifest.json in, web-ext [1] is handy for running extensions in Firefox and Chrome in a temporary profile/developer mode. It also reloads the extension when you make changes.

This is particularly useful if your script grows to the point where it could benefit from an options screen, as you can configure `"options_ui": {"page": "options.html"}` instead of having to hack an options UI into the target site yourself.

[1] https://github.com/mozilla/web-ext

I’ve been really into using scripts to enhance my browsing experience, so much so that I’ve spent the last 6+ months developing these extensions to curate my experience on the Web:

- Intention (https://getintention.com) - Pauses distractions so I can scroll less and do more

- Hide Feed (https://hidefeed.com) - Replaces feeds with my daily focus

- Hide Likes (https://hidelikes.com) - Hides vanity metrics for a more authentic experience online

They’ve made a significant difference to my browsing experience —- give them a try!

Tampermonkey, ViolentMonkey and GreaseMonkey are all available in Firefox.

Can anyone provide a comparison?

Edit for the early commenters: as I stated, all of the above are available on current Firefox. Greasemonkey also has been ported to webextensions. Hence my question.

Edit 2:

TamperMonkey is closed source source and apparently embeds Google Analytics. Either of those immediately kill it for me, considering the kind of access the addon gets.

ViolentMonkey "does not collect user data at the moment", but also allows for it in the privacy policy.

I think I'll stick with GreaseMonkey.

Strongly agree with the original article, and it's fun to see all the niche use cases that people are mentioning here.

But I have a major frustration with user scripts: writing them requires experience with Javascript and reverse engineering websites. This is fine for the HN crowd, but locks out most web users, who can't program at all.

I bet that if it were slightly easier to develop user scripts, there'd be 10x as many of them. I'm sure I'm not the only one who's helped a coworker write a bookmarklet / user script essential for their workplace sanity.

Would be curious what people's experiences have been helping nontechnical people extend websites, or if you know of tools in this area.

My current attempt at this is a project called Wildcard, which requires a programmer to write some site-specific scraping code, but then shows the scraped data to the end user in a spreadsheet and lets them decide what to do with it:

https://www.geoffreylitt.com/wildcard/salon2020/

Userscripts are great. I'm using it mainly for adjusting page styles (similar to Stylish[1]). I'm reading this very HN page in my custom dark mode. But I've also created some behavior-altering or automation scripts, some of them being open-source [2]. Adding a "@downloadURL" attribute makes it possible to sync the scripts easily across all devices (and users). Userscripts was also my main reason for switching to Firefox, because the mobile version supports Addons.

[1] https://userstyles.org/

[2] https://github.com/darekkay/config-files/tree/master/userscr...

15 years ago i used userscripts for ... kinda cheating at a popular browser game. i didn't do anything _really_ illegal, it just extended the UI.

e.g. if you sent an army to rob a village, it stored the type and level of workshops and calculated how many troops you'd have to send plundering the next time.

it worked really well. next i changed the backend from local storage to a shared database and shared the script with a few friends from my clan. that kinda broke the game. we were incredibly successful but i also immediately lost interest, quit the game and killed the server.

Funnily enough, one of my first GreaseMonkey scripts that I wrote 9 years ago was one that added the ability to collapse threads here on HackerNews [0]; this functionality was finally added in the past year or so to HN (not based on my implementation).

Worked like a charm back in the days :)

Another more popular GreaseMonkey script of mine was the Wikipedia TeX Source Extractor [1]; I used it extensively during my studies when writing lecture summaries, papers, or my thesis.

Userscripts are definitely fun and can be quite useful.

[0] https://github.com/giu/hacker-news-threadify

[1] https://github.com/giu/wikipedia-tex-source-extractor

Update: After not having touched the code of [1] for over 8 years, I just updated the userscript to work with Firefox 75.0 and the GreaseMoneky add-on v4.9.

[I posted this as a "Show HN" a few days ago [0]]

I wrote a short JavaScript snippet to export HN Favorites to a CSV file. It scrapes the HTML and navigates from page to page.

Setup and usage instructions are in the file.

Check out https://gabrielsroka.github.io/getHNFavorites.js or to view the source code, see https://github.com/gabrielsroka/gabrielsroka.github.io/blob/...

[0] https://news.ycombinator.com/item?id=22788236

MediaWiki (the software that runs Wikipedia) has extensive built-in support for user scripts. There's a decent number of them, too, used for everything from automation of batch tasks to adding any feature one could ask for to the interface. I've written a few myself. Actually, the first programs I ever wrote that other people really used were user scripts. I remember live-debugging one with several users in my ear via TeamSpeak once. "Working yet?" "Nope." "Nah."

https://en.wikipedia.org/wiki/WP:User_scripts

The company I work for basically relies on use scripts to make any of our internal tools usable. Its kind of insane and makes on-boarding new employees somewhat difficult when they aren't even looking at the same UI as tenured people.

Here is the one I advertise the most

https://greasyfork.org/en/scripts/811-resize-yt-to-window-si...

https://github.com/Zren/ResizeYoutubePlayerToWindowSize/

The only thing that would irk would some, I think, is that any stats/details are out of sight, a scroll/pgdn away

Highlight new comment on HN

https://greasyfork.org/en/scripts/18066-hn-comment-trees

For reddit:

https://github.com/Farow/userscripts/blob/master/reddit-high...

Gmail android creator had a unified one for HN+reddit that syncs across sessions, but it lacks features and haven't been updates in years:

https://chrome.google.com/webstore/detail/new-comments/jldpf...

My most used bookmarklets increments playback speed for html5 videos, i have one that +0.5x and one that -0.5x

javascript:(function() {var media = document.querySelectorAll('video,audio'); var rate = media[0].playbackRate+0.5; Array.prototype.forEach.call(media, function(player) {if (rate == null) {return;} else if (rate != 0) { player.playbackRate = rate; } else {player.playbackRate = 1;}}); })();

Also skip forward / back 30s

javascript:(function() {var media = document.querySelectorAll('video,audio')[0];media.currentTime = media.currentTime+29;})();

Forgot:

https://timelens.io/youtube/

Great great for skipping past ads or blocks of content based on visual timeline. Wish this was in more in native media players.

I have severe photosensitivity; large blocks of white hurt my eyes. I use userscripts with Tampermonkey to change sites like this one and Github to a dark color theme that my eyes will tolerate much better.

This is how Hacker News looks like with my script: https://i.imgur.com/We97pJC.png

Numbers on the left (11, 12, 13) are shortcuts to open a thread (for example, pressing 14 opens the "Userscripts are fun..." thread).

Numbers after that (e.g. 65,20) are karma and number of comments, respectively.

Much more compact than the default layout and shows better which topics are hot.

Recently wrote a userscript to sync video progress with my friend via peerjs. Works like a charm. And it supports any <video>. The edit-reload dev experience is still much better than extensions.

I recently wrote a tiny alternative to the mentioned webpack plugin https://github.com/nfour/TinyWebpackUserscriptPlugin

Using it in this project with some userscripts (see webpack.config.ts): https://github.com/nfour/userscripts

Tampermonkey seems like the best script manager for developer experience (as far as I could tell from trying the others) when configured as recommended (removing cache checks etc.), though it still requires 2 page refreshes to show changes.

If anyone knows of an improved workflow I'm all ears. I'd like to see something closer to webpack hot reloading, though I suspect we either need a new script manager, or a userscript framework that can be configured to hotswap code.

Perhaps browser managed content scripts will be viable? https://github.com/violentmonkey/violentmonkey/issues/604

I made this bookmarklet for Mixcloud to be able to save the current track to my YouTube playlist.

    javascript:window.open('http://google.com/search?q=' + [].slice.call(document.querySelectorAll('span[class*=TrackInfo]')).reduce((acc,el)=>acc + el.innerText.split(' —')[0] + ' ', '').trim())

> Nowadays the internet is pretty decent for all

... what? The web is rapidly becoming more and more unusable. Often, sites only work well when I fully disable JavaScript, and the associated autoplay ads, trackers, custom half broken and CPU intensive navigation behavior overrides, and similar sources of misbehavior.

The modern web is more user hostile than ever before.

My main use case for user scripts is to automatically authenticate on brain dead corporate sites. webex is one example where you cannot save name/password in the browser per default.

Yeah, as a developer I still use userscripts and also create them sometimes. Just some days ago I updated my Wikipedia Flag Icons e I recently created a super simple one to sort Linkedin feed chronologically by default. Both are open source and available as extensions too:

- https://github.com/DavideViolante/Wikipedia-Flag-Icons

- https://github.com/DavideViolante/Linkedin-Feed-Sort-By-Rece...

Are userscripts still run once after page load? That was a major pain point last time I tried using them, on a dynamic page. I tried hooking some events and run-registered-function-on-tree-change-but-at-most-at-N-msec-intervals, but it got out of hand and ended up looking to take much more time to write than the handler it was going to call, so I filed it under "should be written once and properly" and postponed the whole thing.

I block cookies (and some other stuff) on YouTube, which also causes all of my settings to fall back to the most annoying defaults possible. So I use a combination of userscripts and userstyles to batter the YouTube client until it does what I want (i.e. a dark theme by default, auto-pausing of channel trailers, a sane default volume and a few other things). It's pretty amazing how powerful userscripts and -styles are!

I installed TamperMonkey recently and wrote some scripts to improve my Twitter experience. Very handy. Then it popped up a request for donations screen, which is an understandable approach by the TamperMonkey author, but I became uncomfortable that TamperMonkey was watching everything I did on the web and reporting back to the author, so I uninstalled it.

One of my favorite browser extensions, Simplify [0], started its life as a userscript/userstyle.

I've used Greasemonkey scripts to fix stupid (and in one case, broken) things on mandatory intranet sites. They're invaluable.

[0] https://github.com/leggett/simplify

For me, userscripts have been a great way to learn javascript. I have no programming experience and the ability to find something I want to tweak and be able to implement it on a web site is pretty cool. I created a userscript a few years ago and during the quarantine I've been learning a lot rewriting it to work better.

I've spent 9 years maintaining a userscript for a website that now has a new beta in React. Boy, is that a pain in the behind comparatively. I'm pretty sure what I'm doing on the old version of the site won't be possible, but that is yet to be determined.

I am surprised by the fact that my userscript (Local YouTube Downloader) is mentioned. Thanks!

I’ve written extensive user scripts to improve inferior web interfaces of tools that we use for work. My two biggest ones are for a work tracker and a support system. The support system one especially is considered indispensable by the support staff and almost everyone else that ever interacts with it. (Why not just change support system?—you may ask. There were certain features that provided the concrete reason for staying with that one. And in bigger businesses you often don’t have the flexibility to choose different things anyway.)

A fair fraction of the user scripting is actually just stylesheets, and indeed I started out with just user stylesheets. It’s amazing what you can do with such stylesheets. You can reduce borders, margin and spacing, reorder sections with flexbox and/or grid layout, hide irrelevant functionality or data fields that you never use but the tool doesn’t let you hide, emphasise details that are important to you, reduce the need for scrolling (more efficient layout is routinely able to make things 30–50% shorter without feeling in any way cramped, because many layouts are simply unnecessarily wasteful of space), make sidebars sticky to save scrolling, increase the size of elements and popups that are inexplicably small with forced scrolling, and loads more.

And that’s just the styles part. Add scripting and you can do things like set the document title because the system just sets “AppName” or “Manage Request”; automatically click on “load more” links; restructure content for better consumption; in history streams collapse automated things with a single line summary, or bulky tables of the fields that changed with more compact representation; highlight things differently based on the result of some function on the element (e.g. who wrote it), change how times are presented (e.g. replace an absolute timestamp with absolute and relative, plus showing other timezones that could be relevant in a tooltip); add a button to copy the ID or link for an item; and much more that I haven’t even thought of yet.

My user scripts are readily configurable: each feature can be turned on or off independently, since a few of the features some people like and others don’t.

I’ve thought and said before that this should be a plausible business: forced to use a web app that’s slowing you down? Hire me and I’ll make it easier and faster for you to use. I guarantee improved happiness and at least some productivity boost, and enormous productivity boosts are possible, like orders of magnitude in some cases, by better information presentation and automating arduous human-driven tasks.

There’s always the danger that the app will change underneath you, but this isn’t often a problem.

If you’re interested in this idea and have any web apps that you might like help with making a user script to improve, email me at userscripts@chrismorgan.info.

Since 2012 I'm using a userscript I wrote to inject a button to each github code comment to open my editor at the file-and-line.

It feels strange this is not something more people want, but I haven't seen any other project that addresses the same, so I'm still kinda maintaining it:

https://github.com/kidd/org-protocol-github-lines/

> We could create a browser extension, but that means developing one for all major browsers.

No it doesn't. A single webextension works across Firefox, Edge and Chrome. Safari is an exception though.

https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/Web...

How about pushing for browsers to allow for the same functionality browser wide? And, yes, I am still bitter about firefox killing vimperator.

So the last time I tried to make an extension (I believe in chrome) for an application I work on, I could not access data stored in the global object - I was trying to make data available to the extension to do more with and show like debug information. Can you access js variables with userscripts like you could in the developer console?

I can't believe that cut-n-paste can be modified by websites and it isn't easy to regain control. For some sites, when you copy a text selection it adds the url as well.

I really wish you could tell your browser to disallow this kind of modification. I only want to copy what i see with my eyes. (WYSISYG)

As someone who has made a number of userscripts to improve his experience with various websites (mostly for work), I'm glad they're getting some attention :)

So often simple UI changes like resizing a textbox or adding the ability to collapse comment threads can make a big difference to your experience.

I wish there were a userscript equivalent for API's. e.g. someone could make and share a script to get flight details from the Gmail API. The advantage would be that I could run the script rather than give an oauth token to a third party to run it on my behalf.

What's the security story for userscripts?

If somebody could tell me how to use user scripts and user CSS on Brave mobile, I'd be a happy person.