Tools you have made for yourself?

I have a small YT channel [1] and I used to spend 30-40 mins recording and then 2-4 hrs editing to get a final 10-15 min video.

Then I fully scripted my video editing using Python+MoviePy [2]. The time savings are sweet. I just feed it my raw video and get the finished video a few minutes later. It cuts out all the dead air as well as the parts I don't want (which I indicate in-video).

In general scripting video editing is faster and more scalable compared to mousing around and making tiny cuts in a graphical video editor.

[1]: http://youtube.com/c/VivekHaldar [2]: https://youtu.be/Bdoi7BDhrWc

This should be a monthly thread in the middle of the month — to avoid overlap with the hiring/who’s

I’ve loved getting to know our community this way

I wrote a tool that reads numbers from stdin and outputs the percentile statistics of those numbers.

https://github.com/zdwolfe/zstat

https://pypi.org/project/zstat-cli/

    $ cat nums.txt
    456
    366
    695
    773
    ...

    $ cat nums.txt | zstat
    p0      =       56
    p50     =       366
    p90     =       773
    p95     =       773
    p99     =       826
    p99.9   =       826
    p100    =       826

I built a weightlifting workout tracker. I did this because at the time I wrote it (2014) none of the current tools fit my use cases due to the fact that I compete in the sport of Olympic weightlifting and this was still pretty rare back then. I also wanted to be in control of my data and be able to run analysis on it as I saw fit.

I began by writing a django app deployed via heroku. I then decided I wanted to rewrite it in ruby on rails because I had never worked with rails in my career and was already working on django professionally. I then wrote a react/redux SPA frontend, not for any other reason than to practice and learn those libraries. Finally, I decided to buy a VPS and manage deployments myself because I wanted to learn some basic devops stuff myself.

Building and maintaining this project I got first hand experience on building a web application from scratch, designing UX and product requirements, maintaining my own infrastructure (Linux server hardening, supporting SSL, managing my own domain, etc) and got experience in languages I didn't work in professionally. Also I got a few friends to begin using my app and immediately found where my poor UX choices were, which was pretty enlightening.

I think the experience really boosted my confidence as an engineer. I had to learn a whole bunch of new skills and become my own one person startup. In the end it helped me appreciate all that goes into building a software product and highly recommend the experience. I still track my workouts using the app and now have 7 years of data.

I once wrote a script to record the Tinder profiles I swiped left and right on, then fine tuned a CNN using the data and integrated it into an automatic swiper. It swiped right on my now partner!

I operate a long-form nonfiction website, and back in 2012 we wanted to introduce a podcast episode version for each of our articles. I started tinkering with making recordings, but I suffered from the cringe of hearing my own voice, which was amplified by hearing every mistake and retake.

I finally got past this problem by rolling my own audio recording software. I paste in the script, and the software highlights one sentence at a time. I tap a key to start recording that sentence. If I make a mistake or I'm not happy with how it sounded, one key press discards the audio and restarts the recording. When satisfied, one key press moves it to the next sentence.

When I'm done, I can download all of the recordings into one merged WAV, and I never have to hear any bad takes (it also trims 0.1 seconds from both ends of each sentence's audio so the key press noise is removed).

It's a little clunky, being home-grown and all, but it works great. Recording stuff is pretty easy now. I keep thinking about making it available to the public, but it's not yet polished enough for that.

I had a major bike accident, shoulder dislocation that took weeks to recover and broken pinky.

I couldn’t type with my left hand, but I couldn’t afford not to work. I looked into one-handed keyboards, found a variety of half-keyboards that mirrored the other half while holding the spacebar. These are patented, and I also couldn’t afford them.

Being patented, I was also unable to find software offering the same. So I learned enough Objective C to build it for myself. It was a hacky, crashy mess but I never intended it to be production quality… so I also built a monitoring app to relaunch it when it crashed.

It wasn’t anything special but it got me through that recovery!

Whilst learning classical Arabic it was a pain when reading to search through the Hans Wehr dictionary by first extracting the root letters of the word and then looking up the root and then finding the correct form.

So I put together a frontend [1] to search a scanned version I found of it. It has now evolved in to an offline PWA, which you can search from Arabic to English and English to Arabic, convert numbers in both classical or modern Arabic form, stem words etc. When searching in Arabic it removes affixes, prefixes, suffixes and also uses multiple stemming algorithms to obtain the root if an exact match is not found.

It's pretty neat and makes reading so much easier no matter what device I'm on. It's also used by other professors, teachers, students and friends who are also in the classical Arabic field.

[1] - https://dictionary.ilmwaa.ml/

Probably not the kind of tool you are asking about, but I made a pair of woodworking planes that cut a quarter inch wide, quarter inch deep groove a quarter of an inch from the edge of a board. This operation is commonly needed for drawer bottoms and raised paneling. Two symmetric planes are needed so that you can always work with the rising grain of the wood.

You can buy adjustable grooving planes and old molding planes that will do this, but it was fun (and much cheaper) to make my own pair.

1. I wrote a thing that logs the currently active window primarily for Ubuntu. Useful if you bill hourly and want to track total time spent.

http://sentried.ognjen.io/

2. I use markdown files to keep notes. So i made a couple of scripts to keep that organized. It can quick add new notes and create indexes.

https://ognjen.io/markdown-notes-improvements/

3. No longer live: I made a printable forms builder. In a previous company we had to make custom paper forms for registration for every client so I made a thing that made nice printable forms.

4. A thing for estimating Trello cards. You would import a board. Then invite people. Then everyone could estimate all the cards without seeing other estimates. The owner would then see everyone's estimates and could accept an average and automatically tag all the cards with something like "effort: 3".

If you're interested in 3 or 4 email me and I can dig them out.

5. I made a few customizations to Jekyll including being able to publish posts from external folders.

https://ognjen.io/categories/jekyll

I wrote a small Python script that will SSH into my remarkable paper tablet, copy all of the raw files to my desktop, and then convert the binaries to pdf. I use this tool on a daily basis to offline backup my handwritten notes.

https://github.com/awwong1/remarkable-cli

Decoder Ring: https://james.darpinian.com/decoder/ to look up error codes. Started with OpenGL, then added Windows error codes, Linux, HTTP, and Vulkan.

I was a bit frustrated always pasting error codes into Google, as it doesn't always come up with the best result. You often have to extract just the code from a larger message, and potentially convert to/from hex or signed/unsigned, e.g. Windows error codes like "-2005270521". My tool handles all that for you. Just paste an error message containing codes in whatever format and it'll find them, and it's incredibly fast.

I also made https://aqi.today during the California wildfires. I was frustrated by other air quality sites that load way too slowly and don't emphasize the one number that matters. Airnow.gov has improved since I made this, but but I still prefer mine for the simplicity, speed, and much better data sourced from Purpleair. Airnow.gov sensors are typically 5+ miles apart, and data is delayed by an hour or more, while air quality can vary on a block-to-block and minute-to-minute basis. Purpleair has far better sensor coverage and data is delayed only 10-20 minutes.

"tell me what tools you've made and i'll tell you who you are." Really.

Probably i make one sw tool per month - whatever annoys me enough to go over the lazyness treshold.

Most of my toys (made last 25+ years) stay at https://github.com/svilendobrev/svd_bin

https://github.com/svilendobrev/svd_util (python stuff)

apart of the bigger ones there with own repos

most used stuff seems:

* shell wrappers/configs to make using terminals a more humane+repeatable thing. A system (="language") of plenty of aliases and shortcut keys, for many combinations of x-terms/shells, so regardless of which one it is, it gets same human interface. Remember 4dos? there. F2 is dir/ls..

* similar thing for vim. F2 for save. ctrl-f for find. etc..

* vcs.sh - similar thing for 5-6 revision control systems

...

* sound files searching/cutting/diffing - searching one record within another - think recognizing start and end signals of some radio show, cutting it out from several alternative recording sessions - e.g. digitized analog vs http/rtmp streams; and diff'ing the results ; the timeline can be warped a lot (Wow and flutter, yes, with some charts out)

* hundreds of others.. some of them i dont remember anymore what they were for :/

have fun

I was annoyed by the seemingly over-engineered tools for screen tracking, so I wrote one myself in ~50 LOC, which simply uses ffmpeg to create a screenshot every X seconds in a very low resolution:

https://github.com/instance01/mac-screenshot-tracker

It's super hackable and gets the job done.

I have an unorthodox system of things which is all quite interdependent. I prefer to just adjust things as I go. I know I'm reinventing the wheel at times, but I would rather a more personal UX than a UX for the lowest common denominator.

I have a variable loader that I can use in scripts/programs so that I don't have to hardcode filepaths and so I can change settings quickly. Variables can refer to other variables, even in parts of them. I can quickly insert references to those variables into scripts/programs with a shortcut key.

There is a note taker: a shortcut key immediately opens a blank file (which is named the date + time + a short unique ID to avoid any clashes).

There is also a note reviewer: It shows the next note to refine. I can postpone any that are uninteresting yet incomplete for whatever duration, and archive any which are complete and can show up as relevant matches elsewhere in my system. This stage allows me to deal with bits and pieces at a time, and review things I'm still working on. It avoids hierarchical constraints on purpose, and it breaks things down into tags instead.

I have a sort of data representation in which I can note how things/concepts are linked, and also express doubt, references, references to references and so on, to allow expressive representations of thoughts including incompleteness or ambiguity.

I have a music player that devalues a track every time it is not played in its entirety. The faster it gets skipped the more it gets devalued (and there are meta keys to add more weight). If a track's rank doesn't meet a random threshold then it gets skipped. It basically stops the listener getting too used to a track even though they may like it.

https://github.com/roveo/vertica-query-paste

This is a small script made to do one thing: take an SQL query from the clipboard and output a CSV file with results.

As a data analyst, part of my job was sending results of ad-hoc queries to a bunch of people on slack. The data warehouse was quite slow, so I had to:

- write a query in DataGrip (or any SQL client)

- execute it

- wait for results

- remember that there was a request for data

- save the results to CSV file (with my mouse)

- send it to the person on Slack who asked for it

With many requests per day, many of them concurrent, this was a problem.

With this tool, I just had to write a query, make sure it works, copy it to clipboard and execute:

  vertica-query-paste | slackcat --channel some.person

and not worry about remembering to send it afterwards.

I also had an alias in my shell set to

  vqp=vertica-query-paste | pv -l

and a bunch of shortcuts for slackcat for people that most often asked for ad-hoc query results.

It works with Vertica, but can be generalized to any DB engine that has a CLI client.

Really simple, but probably saved my many hours.

A couple years ago I moved somewhere where my only internet option is satellite (HughesNet). The data caps are pretty low (50 GB per month) but if you use data on the “bonus zone” (midnight to 8am IIRC) you get an additional 50GB quota, so I wrote a tool that lets me queue up YouTube videos to download in the middle of the night. It’s a pretty simple collection of scripts that shell out to youtube-dl. I wrote it in TypeScript just because that’s what I was writing at work at the time: https://github.com/dylanscott/downlater

I’m still using it often a couple years later, though I’m hoping my Starlink pre-order will come through soon and render it obsolete.

I built a tiny Windows desktop app to hide files on my lap top from anyone who might be using the lap top briefly - visiting in-laws, friends who wanted to check email, etc. Building it was triggered by a nosy but technically un-savy sister who was always poking around.

This was about 8 years ago and I use it on all my machines since, even work ones. It 'hides' files by randomly renaming a folder's contents and removing the file extension. Simple, but surprisingly effective.

I called it Cloak My Stuff.

https://badwolfsoftware.com/cloakmystuff.html

I have never contributed much to open source, but my high water mark was writing reportdhcp, the first available tool to report the status of DHCP pools. I wrote it because I needed it and none existed that I could find anywhere. It got packed into a few distros. After only a few years it was replaced by better tools (and in fact, I was even proud of the fact that the author of one specifically called out that it was better than reportdhcp). Got written up in Linux Magazine and one other publication at the time. I'm no superstar like many of you luminaries, and in fact I wrote it with the Llama Book sitting in my lap, but it was great to contribute the open source ecosystem to which I owe a large chunk of my career.

== killUnusedTerminalsAndBC.sh ==

This kills off any open bc instances I have, and then any open rxvts I have which aren't running another program

After a day or so I can easilly have 100+ rxvts in the background, some of which are running vim, some sshed into other servers, but many of which are just old windows I ran to do something briefly but never killed off

== another config differ == Someone else on the team had a nodejs based config checker (a script which every 10 minutes logs into -- like rancid, but looking nice). It broke after some minor change in one of the 456,914 imported scripts, so I bashed together my own and dragged in a visual diff tool.

I looked at rancid but it felt rather cumbersome, and I didn't want to store stuff in an VCS, it was quicker and easier just to do it myself

== vlc multiviewer == I wrote a VLC wrapper in python using a VLC Gtk widgit to give me a multiviewer so I could monitor multicast RTP streams and easilly mute/unmute from a touchscreen

== continuous pinger == Just a program to sit in the background pinging a list of servers continuously, traceroutes every 10 minutes, and storing them, then a webpage to show the results and summarise them (highlighting any losses and pinpointing the exact second, etc)

== multicast test tools == A couple of quite python multicast send/receive tools to check connectivity. The receiver can also dump out an output and generate a jpeg from the contents (using ffmpeg), and ties into monitoring to ensure that the streams are all working and we haven't had something like pim dying on a router (which has happened in the past)

== cheese.sh == Loads up mplayer to cheesefm and logs what's played (ICY Info lines) to a text file (having first rotated the last one)

== sshold == To ssh into old cisco switches. Barely a script

  ssh -oHostKeyAlgorithms=+ssh-dss -oKexAlgorithms=diffie-hellman-group14-sha1 $@

A window sill-desk/laptop stand. I could place my laptop on this and look out the window at the same time whilst working. At the place I used to work we had some awesome views of the mountains, especially on the upper floors. I couldn’t stand staring at cubicle walls, so I would take breaks to walk around and see the amazing views. Eventually, I made the sweet desk. I could have my laptop on top with a wireless keyboard, or put the laptop below. I cut it to the dimensions of my height and where I like to rest my hands. There were some silicone strips/bumpers underneath to keep it from slipping or sliding or scratching the wall. Pics: https://photos.app.goo.gl/VJLQqUhzHjPt4uCB8

Sounds dumb but I go camping a lot and still want to access various informational APIs when I’m in limited cell reception areas so I built a bridge that allows me to hook my APIs up to text messaging. I just send a text like “news” and get the latest headlines over sms. It works pretty well even when I don’t have data access I can still usually get the text messages back.

I have so many of these things that I use daily.

I made a CLI password manager in Bash. It grabs random bytes from /dev/urandom, filters out the non-ASCII, then GPG encrypts with my key. Months later I realized I had reinvented the common utility 'pass'.

I made a utility to type accented characters on Linux. I learned to type French on an English keyboard under windows as a kid using Alt + 0NNN where NNN is the decimal character code. I made a delightfully hacky solution: when I press Alt+0 a tiny window is popped for a fraction of a second to capture the next keystrokes. If they are 3 digits, it spits out the relevant character into the active window. This one is also in bash.

The car share service I use got rid of their web interface. I reverse engineered their android app and created my own unauthorized web app so I can find available cars.(evofinder.ca)

I built an embedded device that connects to the door buzzer in my apartment so I can let myself into the building. It's built with a cheap esp8266 dev board and programmed with the arduino IDE, yet it has been running reliably for years.

I built a mobile trivia game web app that is simple and lightweight with no ads or tracking. I made it pre-COVID to kill time when I was out and about. (Justtrivia.fun)

If you want more info about any of these, check out https://jeremypoole.ca/posts

I am the original author of LatexMk[1], a Perl script that runs Latex the correct number of times to ensure all cross-references and such were resolved. It can also run continuously with a previewer and several other goodies.

I wrote it around 1993 to scratch my own itch, adapting it from a little script called “Go” by David J. Musliner. At the time I was using a literate programming tool that generated Latex from C code. When I moved on from that job a couple of years later, I released a final version two, which documented that I was no longer planning to maintain it. Since then John Collins took up the cause and been doing a wonderful job from what I can tell from occasional ego searches through google and stackexchange.

Two amusing things: 1) It is the only piece of Perl code I have written, ever, and 2) I had reason to use Latex a few years later, and decided I really dislike the sheer complexity of it all. Despite that, it is surely the most enduring and widely used piece of code that I can claim credit to having a hand in.

[1] https://www.ctan.org/pkg/latexmk/?lang=en

I have recently developed my own terminal-based UI for todo/task tracking [1] in markdown files because I was sick of rearranging todos in other tools.

The main advantage is that you can "migrate" all unfinished todos to a new page/day and thus get a clean start each day. This idea comes from bullet journalling.

To get it done I had to dig a bit into ncurses, which turned out more interesting than I thought. For instance, Windows Terminal just gained support for bracketed paste a couple of months ago and my tool supports it.

[1] https://github.com/coezbek/rodo

Stack: Ruby, Curses, Markdown

I wrote a command line journal called 'did' that shows me what I did on this day over the last five years (like a 5 year diary). I enter a ton of items every day which all end up in text files. Only items including an asterisk will be repeated back to me in future years.

Inspired by: https://news.ycombinator.com/item?id=17538697

Not sure whether this meets your "definition of a tool" but I started tracking my investments publicly a couple of years ago here

https://docs.google.com/spreadsheets/d/1tBrZEMFK9XNWxiqOxE8o...

The GoogleFinance Function has been a great way to help me "visualize progress" in a very different way compared to default visualizations provided by stock brokers

I have also tried to keep track of analytics more manually but hope to find some time to automate later (if you wanna help, lmk :)).

Basic metrics like the following: Hit Rate: % of investments that had a profit / Loss Rate: % of investments that had a loss / Size of Avg Winner / Size of Avg Loser / Expected Value of Investments / Win to Loss Ratio / Avg Holding Period / Opportunity cost analysis (eg: what is the stock price say 12-24 months after I sell?)

These basic things would help the individual investor get a lot more insight than they can easily get today.

https://mark.show so I can present ideas quickly.

I wrote an in-terminal histogram tool[0] because... that's when/where I always need histograms.

[0] https://github.com/wizzat/distribution

I built a kanban board with two goals:

1. Dark mode by default

2. Dead simple

I am looking to make a couple of WPF projects over the next couple of years and wanted to track them but found all the online Kanban tools missed the mark by miles in one way or another: in particular, they were all far, far too complicated.

So I built my own: https://allthetasks.com

It's not long up and missing a bunch but it works and scratches my itch :)

Edit: Oh, almost forgot. It was also to use some of the stuff I don't get to use in my day job... we tend to just build something and ship it as fast as possible (development speed, not application speed) so I wanted to make something as small as possible and fast as possible too!

https://www.npmjs.com/package/tavuelo - I've created own Vue.js table plugin because I was so annoyed with customizing another table from UI library for the 100th time to achieve similar result so I've created a dedicated solution that will cover most common problems/requirements I need to develop at work.

https://github.com/writteli/writteli - I've created static site generator because I've wanted something that suits my needs for 100% and I won't need to "fight" with the 3rd party solutions to achieve what I want. Also I've wanted to learn something during the process. I'm using it on daily basis to maintain my website (https://lukaszkups.net) and also now I'm working on a desktop app that will be compatible with it.

https://github.com/mrmnmly/scaffolder - I was sick of creating boilerplate code over and over again when I was doing my baby steps with Meteor.js so I've created a stupid simple bash script that will generate it for me.

Recently I released a webapp to fix a problem I faced. I can paste any image from my clipboard (mostly screenshot in my case) to get its base64 version so I can integrate it directly in any markdown: https://paste64.vercel.app/

It was also an excuse to try out Svelte with TypeScript: https://github.com/aloisdg/paste64

I wrote my own terminal emulator stack. I was annoyed that the colors were often unreadable on others and that shift+page up wouldn't work to scroll from inside gnu screen that I used to use. So I rewrote the whole thing from scratch, my own terminal emulator and my own replacement for gnu screen. The terminal has both a custom palette and refuses to display certain combinations (if you ask it to do white on white, for example, it will do grey on white instead) and forwards various things like the shift+page up keys all the way down (and on the other side, commands like clipboard paste request all the way too), so when I ssh to the desktop and attach the session, all my habits still work.

I know it sounds like overkill but it just really bugged me to strain my eyes and have to hit different weird keys depending on where I was.

In an attempt to gamify my own fitness, I wrote a simple workout tracking app that used energy bars which depleted and refilled over time. If I hit a particular muscle group that day, the energy bar for that muscle group would deplete and take a couple of days to recharge. The idea was to keep all the muscle groups on cool-down. It was actually quite fun for a while. Kind of like looking at a simulated representation of your body recovering over time.

It seems like a toy compared to most of the other tools in this thread, but FWIW I have a little script I call "did":

    grep "$1" ~/.bash_history | tail

It just shows me the last ten commands that include a search term. E.g. "did foo" shows the last ten commands that include "foo".

Got tired of paying for SSL certificates on WordPress. Built a plugin that generated free SSL from Let's Encrypt: SSL Zen <https://wordpress.org/plugins/ssl-zen/> It's now used by 50,000+ websites.

I was tired of bringing up environments with multiple tools (packer, ansible, terraform, chef etc)

So I wrote a tool that coordinates tools. It's configured as a graph, more specifically, it's configured as a Graphviz file.

Here's a graph that brings up Hashicorp Consul, Kubernetes, Prometheus, Hashicorp Vault, Java private web server, Debian repository, bastion box. It brings up workers as part of the build process. The workers run the actual tools.

https://github.com/samsquire/mazzle-starter/blob/master/arch...

The graphviz looks like this: https://github.com/samsquire/mazzle-starter/blob/master/arch...

Essentially you define dependency -> depender in the graphviz file.

It runs all the tools in parallel and has a GUI.

https://devops-pipeline.com

Every night at midnight, I have a script that sends me a blank email with a smiley face as subject. It’s a nice way to very quickly distinguish emails from today, yesterday etc. and also to stunt my prior that every email I get is going to be stressful.

Tool to generate a random order of a popular food delivery service in The Netherlands. Wanted to discover new local restaurants instead of eating the same 3 things always. http://thuisbezorgdroulette.nl/

I use NYC's bike share system (Citibike) quite a bit. Unfortunately the app's map of bike/dock availability [0] requires a lot of scrolling and tapping to get info, in my opinion. It definitely looks pretty, but it's not so functional. So, I built my own version [1] that is far more information dense, but much uglier.

[0]: https://apps.apple.com/us/app/citi-bike/id641194843

[1]: https://github.com/kevindong/bbam

I am currently learning SQL/Python, I often just wanted to know the headers and how many rows are in a CSV file, so I just wrote a small Python script for it.

  import csv
  import readline

  readline.set_completer_delims(' \t\n=')
  readline.parse_and_bind("tab: complete")

  def csvOpen(file):

      with open(file, "r", newline='', encoding='utf-8-sig')  as csvfile:
          reader = csv.reader(csvfile)
          i = next(reader)
          dRows = sum(1 for line in reader)
          print(f"You have {dRows} rows in the CSV file:\n" f"Your headers are:\n {i}")

  file = input("Please enter the filename to show the CSV   headers: ")

  csvOpen(file)

I also have an alias for it in my .bash_aliases.

  alias sqhead='python /home/user/Coding/Py-Code/sqlHead.py'

I set up wifi on 130 acres on a mix of solar and grid, wired Ethernet, "wireless" Ethernet, and mesh wifi. We have two shakey ISPs. I ping all network devices every ten minutes and plot the results over time. Has helped me tremendously when troubleshooting

This isn’t anywhere near as impressive as some of the examples here, but anyway:

I run an Etsy store that sells artwork. One of the most time-consuming tasks was creating the mock-ups for product listings, so I wrote a shell script that used Imagemagick to automatically generate all the images.

I was pretty pleased as I’d never written a Bash script before and it saves hours and hours of work.

I also wrote a Ruby script that uses the Etsy API to generate a fully-working Jekyll e-commerce site from my Etsy store’s listings. Much better that paying Shopify plus a bunch of other apps for pretty much the same thing.

I have thousands of images of journal entries & notes about things I want to make (music, stories, software) collected over the last 8 years. I'm currently organizing it all with tags and metadata using a Django web app. It's fun, even addictive, and I'm finally getting the insight from my own personal records that I've been hoping for.

What this looks like is gathering my data, spinning up different views and templates based on what I want to do next, using and iterating on the page while I use it, getting a new idea, rinse & repeat.

A few years back, my car was one of the millions with an airbag recall. For months, they sent letters saying it was my turn, but if I called to book an appointment, they'd say they didn't have the part in for me yet, and I had to check a web site to see if it was really my turn.

So I wrote a script that would poll the web site using curl and notify me via Slack if the status had changed. I put that in cron, and every day it would give me the airbag report.

One day it told me that status had changed, so I called and they booked the appointment.

I missed an emoji picker for Linux. I couldn't find anything that was not integrated into Gnome/KDE or maintained. So I set out to write one myself, just a simple Python script with rofi. I uploaded it to Github, because maybe someone else also wanted that. That was several years ago, and now [rofimoji] can do all UTF-8 characters (and custom ones), works on Wayland and is packaged for some distros. I'm so happy how my tiny project turned out and how many people helped with PRs and issues.

[rofimoji]: https://github.com/fdw/rofimoji

Professionally, I (and the whole team) lost track of our deployed artifacts, as we're not on a release schedule but also not really on continuous deployment. Mainly, we released when someone noticed that a release has been running stably on staging for a while. We also needed a way to ensure our configurations were correct and to track API versions. So I started hacking together a small React app (new for me at the time) to collect and display all that information. It had a good welcome in our team, and so a colleague and I improved it a lot, added an actual backend and, for example, integrated it into our CI so that you can now see which commits happened since the last deployment and deploy through it, with just two clicks. We also automated a lot of our previously manual checks for larger deployments. It's become the main tool for that stuff, even for our not-so-technical PO.

I've made a lot of things for myself. Of the things that come to mind:

1. An Alexa Skill that allows me to ask my bookshelf for the position of a book. I've spoken at PyCon India 2019 about this. (https://stonecharioteer.com/2019/10/12/pycon.html) 2. A Discord bot (https://stonecharioteer.com/sarathi.html) to update my blog's TIL page. (https://stonecharioteer.com/til.html) 3. A shell script to connect to the right Wi-Fi at my office (useless now) 4. A script to set/unset proxies on my work laptop so I could download packages from external registries. 5. A script that would collect weather information to correlate with my migraines. This eventually ended up being a correlation is not causation situation. 6. A NAS using a Raspberry Pi 4 so that all TVs at home can stream from my movie/anime collection.

I am in the process of building more things, as a way to learn Rust, and as a way to scratch the programming itch that I have. Do reach out if you want to discuss any of my projects. I will blog more stuff eventually. I use the same handle on Twitter.

I wrote qlip [0], a stupid-simple shell utility written in 5 lines of Rust that prints your clipboard as a QR code to stdout. I used it as a clipboard sharing utility before KDE Connect fixed their universal clipboard feature. It should compile for any platform that supports Rust, and you can install it to your system in a few seconds using `cargo install`.

[0] https://github.com/toasterrepairman/qlip

I used to write Java tests for of asynchronous operations such as sending emails and waiting for them to arrive in a mailbox. In order to poll the mailbox I wrote a small routine that would support retrying actions with configurable intervals. At some point I extracted it into a separate project called retryJ and recently released it as open source on Maven Central [1].

[1] https://github.com/gdiegel/retryJ

I built a documentation platform [1] for work since I didn't want to worry about licensing costs (With something like Confluence) being a factor, limiting potential access, when it comes to documenting and sharing knowledge.

I also wrote a simple little PHP script [2] to check HTTPS certificates (And email results) to help keep on top of things.

[1]: https://github.com/BookStackApp/BookStack [2]: https://github.com/ssddanbrown/sslcheck

I often want to run small "experiment code" many times with different inputs, but don't like wrapping everything in a big framework to do it. So I wrote a little tool that calls any command-line program multiple times with different inputs according to a template and a search strategy [1].

Another upside is that most parameter search programs seem to assume you want either grid search (which is hideously inefficient for large search spaces) or bayesian optimization (which can be overkill and comes with its own caveats). I wanted to make it easy to use quasirandom search [2], which is basically always the right choice for small searches where you just want to understand the parameter space better.

[1] https://github.com/maxwells-daemons/argsearch [2] https://en.wikipedia.org/wiki/Low-discrepancy_sequence

As a Wikimedian who used to spend sleepless nights editing on the Malagasy language Wikipedia and Wiktionary, I have been developing botjagwar (https://github.com/radomd92/botjagwar) on and off for the last 10 years. More details at https://github.com/radomd92/botjagwar/wiki/Backstory

It's mostly bot scripts written in Python. Data is stored in a self-hosted PostgreSQL. In addition to a backend I'd written myself, I also use PostgREST. A rather rustic front-end was written in 2020 (https://github.com/radomd92/botjagwar-frontend) as a COVID lockdown side-project. Other scripts also use Redis as a page cache to speed up operations involving a large number of page reads.

My IT guys at work somehow keep disabling the show hidden files and folders feature in windows 10. So I wrote a program that checks every 5minutes and turns it back on lol

Have an ultrasonic sensor on top of my monitor that's used as a presence sensor to tell the computer when I’m in front of it or not.

Pauses the music player when I walk away and starts again when I return.

More details here: https://www.michevan.id.au/posts/are-you-there/

http://www.micktagger.app

I have a lot of Spotify playlists and I wanted an Alfred like tool to quickly add songs to my Spotify playlists, mostly using my keyboard. There was none out there that I was happy with, so I built it myself.

Fast forward to today, I've added a few more features I wanted for myself - auto removal of songs I skip often, auto like of songs I listen 100% and a smart playlist feature that gathers new songs from playlists I select into one separate playlist, every Monday.

Not small, but myopic in a way.

I've been tinkering on and off with my own programming language for the last couple of years: http://www.adama-lang.org/

The key motivation is dealing with the complexities of managing all the state between people as they play a game with a strong boundary for privacy.

I am debating what my next steps are with what I've learned. Do I focus on growing things around it, or do I abandon yet another project and do something that might actually achieve success.

On a different note. I made my own laptop stand out of carbon fiber because I wanted specific things that I couldn't get out of the store. I am a digital nomad and finally build the thing after 4.5 years of country hopping. Got lots of interest and now working on a production run: https://www.fiberstand.com :)

Software wise, mostly scrapers for classified ads ect.

I'm super forgetful - so i made a simple website [1] to remind myself of stuff. It's useful! I plan to open source it soon too

The other thing I've built for myself is a tool to find domain names [2] (all the obvious ones are taken). It uses a ML model in the background that I trained to generate suggestions, scores them on a few metrics and calls the whois api to check if they're available. I also want to put this one online, for fun & profit.

Hope you like these little projects!

[1] https://www.remindy.me

[2] https://www.namehunt.dev

Edit: ah, i actually found the remindy.me domain name with the ml model, thought it was cute and that's how the website was born

I built a small (borderline trivial) script that I put at ~/bin/update on my regular user account on every server. Its purpose is to do whatever I’ve decided is most appropriate to keep that server up-to-date.

For most Debian-based servers, it’s approximately:

  sudo apt update
  sudo apt upgrade
  uname -a
  prompt me to hit y if I want to reboot that server now. (This is what uname is for: to orient me to where that window is connected to prevent downing a server I don’t want to.)

This pattern means I can customize it for any given server without having to remember what/why for each. (This context is for my home network; I don’t claim that this is a great practice for production workloads, but it’s nice and handy for my home network.)

My SEO Live Test Framework

https://chrome.google.com/webstore/detail/franz-enzenhofer-s...

Runs a lot of SEO checks (including Google Search Console Data) over your websites Static,Rendered and Idle DOM

Built it cause I can and put lots of my technical SEO edge cases knowledge in there.

I made this for fun after watching some breathless microsoft video about AI in VS code which amounted to autocomplete sorted by popularity. I told a friend I could knock out something more useful (at the time) in half an hour. It's a ahk wrapper of howdoi designed to find code snippets from stack exchange and put them right into the code file you are editing. It is so simple but I actually found it pretty useful for learning new languages or for getting a quick reminder how to do that thing you don't use often. https://github.com/irthomasthomas/helpmecode

I work in consulting and struggle to keep all of my calendars up-to-date with between company and client -- I want both domains to see my entire calendar (the union of two or more calendars). Without this I was often double booked because someone couldn't see one of my other events. And auto-forwarding invites had downsides too.

I created a tool to automatically replicate calendar events between O365 and Google calendars once given OAuth access.

Originally I built this for myself, but after a few friends/colleagues asked, I built up additional tooling around it and launched a product.

https://syncmycalendars.com

A webapp to help me calibrate hydraulic models of water networks.

The original concept was in excel and VBA.

I ended up pulling out the engine as a separate open source library which I've used on a few other projects.

https://github.com/modelcreate/epanet-js#model-calibrate

Made something really similar to apple's recently unveiled "universal control," but from Windows -> Mac. Lets me have the mouse wander off the side of the screen if "pushed hard" and it "pops out" on the mac. It has some issues with modifiers sticking and it's hard-coded to my network IPs and screen resolutions, PLUS it requires an unrelated tool I made to actually build the thing; it's on my "open source someday" list but it's not very other-programmer-friendly.

Made lots of other things but that's probably my fave and the strongest one for productivity.

I work in media and have been pushing to improve web page performance for a variety of reasons (better UX, lower bounce rate, load ads faster, higher ad CPMs, etc.)

I created a tool to show how my org (at the time) was doing relative to others, and also to apply a bit of friendly competition to motivate for improvement's:

https://webperf.xyz/

At the time I started, I was at The New Yorker and we were in the top 20, with a Speed Index closer to 8,000. Now its in the 40-50 rank with a Speed Index around 25,000 :(

In the category of old unmaintained tools:

  - https://github.com/linkdd/manyssh : Before discovering ansible/puppet/etc...
  - https://github.com/linkdd/i3tools : For when I was using i3wm
  - https://github.com/linkdd/xautostart : Also for when I was using i3wm without a Display Manager

For more recent projects:

  - https://klifter.datapio.co : Easy GitOps
  - https://klander.datapio.co : Kubernetes Compliance as Code

I made https://kontxt.io to highlight, share, organize, and discover the best parts of the World Wide Web.

People I share articles with now know the exact parts that are relevant and they can quickly skip between the highlights and we can discuss inline to maintain context. It lets me and other people publicly share what we highlight in an easily searchable way so you can find quality content from trusted sources. Want to see what resources other people like you, in this case programmers, found useful and shared. Boom! Now you can. Starting to look into something new that you’re unfamiliar with, say investing, wouldn’t it be great to see what resources other investors previously found useful? Boom! Now you can. Now imagine having this tool at work with all your super smart go-workers? Boom! Now you can. It works for PDFs, too. It’s just a wonderful research and planning tool to save, share, organize, and discuss digital information, which is a huge time saver and productivity booster. Step 1: Google, Step 2: Kontxt, Step 3: Success. :)

It’s really a multi-purpose overlay for the entire World Wide Web with unlimited use-cases. And I’ve recently gained access To OpenAI and have some cool AI stuff coming for preemptive highlights and auto generated reading lists based on interests and past reading history.

I built this tool for myself. I’m an avid reader always looking to grow my skills. If this is you, too, sign up and let’s learn and grow together.

About 18 months ago I started using Letterboxd. Also, I like Roger Ebert's reviews. I wanted both in one place.

So I wrote some code to scrape his nearly 8000 reviews from rogerebert.com and then import them to letterboxd:

https://letterboxd.com/re2/

(I only put the first two paragraphs of his review on letterboxd then link to his full review on his site.)

The hard parts of this were:

- Extracting the text of his reviews correctly from his site's HTML. That wasn't too terrible though.

- Matching his reviews to the correct movies on TMDB. This just required a bunch of trial and error and about 20-30 manual corrections. I employed various strategies to match by using movie title, year of review, year of movie release (if on his review, but often off by a year or two), director, producer, cast if on his review.

I also built this for myself:

https://github.com/jaysoffian/eap_proxy

I should put my bin directory full of random scripts up on GitHub. I tend to build them as I need them. They're often very simple things like:

- jqpaste -- which is just "pbaste | jq"

- jsonl [jq|gron --stream] which takes it input and if it isn'v valid JSON, converts it to a JSON string so that I can paste random log output which is sometimes a mix of JSON and not into jq or gron.

Those are just a couple off the top of my head.

https://github.com/oxplot/pdftilecut : tiles a PDF to help with printing on small printers

https://fpx.oxplot.com/ : Tiny module that allows powering anything with USB-C

Some small scripts:

https://github.com/oxplot/gists/blob/master/flashserve : creates a QR code to transfer a file over Wi-Fi from terminal

https://github.com/oxplot/gists/blob/master/qrconnect : Read a Wi-Fi password QR code from the camera and connects to Wi-Fi

https://github.com/oxplot/gists/blob/master/qropen : Opens a webpage from QR code read from webcam

I made a webapp (sheetUI) that turns a simple google sheet into a beautiful webpage. I used it when I was apartment hunting, amongst other things. I tabulated the data of each apartment I found (fb marketplace, craigslist, etc), along with images, into a google sheet. Then I used my tool to display them as a grid of cards. There were auto generated filters on the top of the webpage that I could use to filter the cards by whatever criteria I choose.

I made it public last year and it's quite enlightening to see what people have been using it for. E-commerce, contacts, work check-ins, image gallery, inventory, workshop listing, etc.

It's not the best tool, and I don't make a lot of money from it, but I'm happy I'm providing value to others. I still keep the free version around since plenty of people are relying on it.

I'm working on a new version catering to business's internal use cases now, with read/edit/permission control capabilities. Hoping to get it out soon :)

https://sheetui.com if you're interested.

I wrote a tool to copy stdout from a remote machine to my windows clipboard. I alias ssh to ssh with port forwarding to a static port that isnt used anywhere, run a flask site locally on my laptop that has an endpoint for accepting base 64 encoded posts for copied data and an endpoint that has some bash function definitions for doing a curl post of base64 encoded piped data to the port that was forwarded over ssh. I have a terminal hot key which does a curl get of the bash functions and imports them.

so this on a remote machine:

some_remote_machine> echo hello | cb

Will base64 encode hello, post that to localhost:1234 on the remote machine which gets forwarded to my laptop flask site, it base64 decodes the text, then since im in wsl, the flask site runs powershell to write it to my windows clipboard.

It's good for note taking and sharing output in slack easily. I also have an alias for cbc or clipboard with command which prefixes the text with the command used to generate the output.

I made HackerCards(https://chrome.google.com/webstore/detail/hackercards/ncblkm...) to easily skim over HackerNews on chrome new tab page.

Another one is Hijri for Chrome(https://chrome.google.com/webstore/detail/hijri-for-chrome/m...), a Hijri date viewer that too made for myself for tracking ramadan fasting count.

And yes my own Chrome theme 'Space Grey'(https://chrome.google.com/webstore/detail/space-grey/cohabkm...)

I used to etch PCBs at home a lot when I was in college. I used a glossy sheet to print the PCB Gerber on it. Most times I had to etch multiple PCBs and then two things used to happen when I used the same glossy sheet again and again. They were expensive where I lived. 1. The glossy sheet would get blackened due to printing multiple times on the same side. 2. I did not have a printer so I went to a cyber cafe to print and he would charge me for every print even though I was printing on the same sheet. 3. I had to carry my laptop to manually adjust the gaps and often it got screwed up.

So, I wrote this script [0] that would combine the gerbers in a single PDF that I could print in a single go. I used it a lot and saved a lot of Money to keep the hobby alive :)

[0] http://rohitg.in/2015/04/17/BoardMerge/

I wrote https://github.com/banga/git-split-diffs mainly to scratch an itch about not having side by side git diffs in the terminal, then ended up adding more fancy features like syntax highlighting and it got somewhat popular.

Here's a shell script template that helps parse command-line options and informs its users of any missing commands that are required to run the script successfully:

https://dave.autonoma.ca/blog/2019/05/22/typesetting-markdow...

Example script that includes the template:

https://github.com/DaveJarvis/keenwrite/blob/master/installe...

A more recent version of the script template is available at:

https://github.com/DaveJarvis/keenwrite/blob/master/scripts/...

Script to filter out records of a .jsonl file based on some property (e.g. only want records w/ a timestamp greater than 163623...):

    import sys
    import orjson
    import argparse

    if __name__ == '__main__':
        parser = argparse.ArgumentParser()
        parser.add_argument('expr')
        parser.add_argument('file', nargs='?')
        args = parser.parse_args()
        expression = compile(args.expr, '', 'eval', optimize=0)

        if args.file:
            stream = open(args.file, 'f')
        else:
            stream = sys.stdin

        try:
            for line in stream:
                json = orjson.loads(line)
                if eval(expression, {}, json):
                    print(line.strip())
        finally:
            if args.file:
                stream.close()

My last tool is WireGUIrd, a wireguard gui client for linux.

https://github.com/UnnoTed/wireguird

A tool for visualizing log file volume over time in your terminal [1]. Useful for quickly getting a handle on traffic patterns during a production incident. This began as a scratch-the-itch project and was also the first useful thing I made in Rust. Two itches scratched :)

A tool for visualizing ping latency as a heatmap [2]. My Macbook's wifi had developed a severe latency stutter every ~500ms that was driving me nuts when using interactive tools like SSH. It was very satisfying to visualize it and see the pattern, and it helped to narrow the list of possible causes.

[1] https://github.com/acj/krapslog-rs

[2] https://github.com/acj/pingrok

I've built jql[0] as a much more uniform and simple to use alternative to jq, with a lispy syntax.

It may seem dead, but it's not. It's just finished, and I'm using it daily.

[0]: https://github.com/cube2222/jql

I built a music player for videogame music formats because the only other player on MacOS that supported them had a terrible UI and didn't support all the formats I wanted. I consider it a tool because I use it a ton during work to play infinitely-looping songs to help me focus.

https://www.mkelly.me/moseamp/

The progression of me building the app was (over a span of maybe 7 years):

- Prototype compiling GME[1] into asm.js, generating sound samples on a webpage, and piping them into the Web Audio API.

- Turning that prototype into a desktop app in order to learn Electron.

- Giving the desktop app a proper UI in order to learn React + Redux.

- Switching to a native node.js addon to fix slowdown/memory use during playback.

- Switching to musicplayer[2] so that I could play Playstation music.

- Adding a Windows build so I could listen to music while coding on my Windows computer with the same UI as on MacOS that I had by now grown accustomed to.

- Adding a visualizer to learn how, well, visualizers work.

- Adding a piano-roll visualizer for NES music and rendering-to-video because my friends who make chiptune videos on Youtube use an old, inflexible program to make their videos.

I would say the number one driving force is that I made a tool I use pretty much every day; tools I've made that are only occasionally used never really motivate me enough to bother fixing them up, but with Moseamp every fix is an _immediate_ improvement in my day-to-day.

[1] https://bitbucket.org/mpyne/game-music-emu/wiki/Home [2] https://github.com/sasq64/musicplayer/

Just yesterday I wrote a command line tool I called “slice” that acts like Python list slicing for lines in a file. It’s a bit simpler than piping head to tail, and I’ve needed it enough times this week that I went ahead and wrote it in Zig. Haven’t used it yet in practice, but I’m excited to!

I have not found a good ebook reader that keeps my state on edge devices and syncs to a server my position. When I had more time to read manga I built this: https://github.com/gravypod/ComicReader

It takes a folder of webp files and remembers your page on local storage. It's not perfect but it's ok. It also prefetches the next 10 or so pages which is fine for reading on a train.

Another, tool that sends wake-on-lan packets and shutdown packets to a windows machine that allowed me to steam stream from a dedicated windows machine: https://github.com/gravypod/SteamStreamScripts

I wrote a URL handler on MacOS where I can configure rules to define which browser will actually open the URL. Rules can be configured based on a URL regex or currently open Slack workspace.

You can target different browsers, including profile (Chrome) or container (Firefox).

I hope to open source this at some point.

I along with 50ish colleagues use a software that has ole object which can be pasted in PowerPoint. The object contains plots which can be modified for axis and zoom etc. Our reports mostly contain these plots which explain acoustic/vibration events in a car. Making a complex presentation is a difficult task considering when you paste these they don’t exactly occupy the space you want them to occupy. I made a neat ribbon toolbar using VB.net (vsto addin) that even updates over network path after PowerPoint bootsup. The toolbar let’s you resize an object and place it on the slide in a click. It also ‘activates’ the object at certain zoom level, so that they are look better.

P.s. I’m not comp sci guy so forgive me if im not using the right words here.

Oh lots. The ones that readily come to mind are my suite of tools for working with ledger-cli data.

The one that I work with most is my reporting tool, which ingests ledger-cli formatted files, dumps the resulting CSV into PostgreSQL and then provides a structure for writing reports.

Most recently I wrote a tool that consumes a spreadsheet generated by Tiller and appends transactions to my ledger files. This has allowed me to automate my ETL process down to just invoking an update command.

https://github.com/peterkeen/ledger-web

https://github.com/peterkeen/ledger_tiller_export

A web based code editor [1] that supported a small set of languages (C++, JS, Go, Python and Rust), it also supported Vim-key binding (thanks to CodeMirror), came with a localStorage based "file system", so you can save multiple file in your browser. You can get the source on GitHub [2]. To host it on your server, you'll need Docker for the runtime btw. It's pretty helpful to code when I only have access to the iPad during the weekend.

[1]: https://kodes.app [2]: https://github.com/huytd/code-playground

I built dockly - https://github.com/lirantal/dockly

An immersive terminal interface for managing docker containers to help me do that from the command line

I write Raycast[0] scripts to automate small, common tasks I do daily, for example:

- Connect my AirPods to my Mac - Count the characters in some text - Create a new text expansion shortcut with Espanso[1] - Start/stop a Focus[2] session - etc.

Because they're in Raycast, they're super accessible to me — I simply hit CMD + Space, type the first word of what I need and hit Enter. Loving it!

[0]: https://raycast.com [1]: https://espanso.org/ [2]: https://heyfocus.com/

https://github.com/learnbyexample/command_help so that I can quickly get documentation for command options. Inspired by http://explainshell.com/ but wanted a cli tool.

Fails for lot of corner cases, but still useful most of the time. Here's an example:

    $ ch ls -Gv
           ls - list directory contents

           -G, --no-group
                  in a long listing, don't print group names

           -v     natural sort of (version) numbers within text

Most recently, this websub-listener[1] to subscribe to websub feeds, mostly just to catch spacex launches. just sends a message to some slack channels, but could be extended to do a lot. Still really happy with how it's working out, maybe I'll extend it with RSS later.

I've had some annoyances with Insomnia and wanted to take a shot at making my own tool. so here's http-client[2].

[1] https://github.com/kryptn/websub-listener

[2] https://github.com/kryptn/http-client

When wunderlist was shutdown i had to find an alternative. I only used basic features of wunderlist and wanted something similar. But all options was just too much. So I built it myself. I've used it every day since. For shoppinglists and work tasks and any household tasks. It's perfect for what I want. It even looks a bit like wunderlist. Https://github.com/lallassu/doit

Then I also wanted to read my news from the shell in a simple manner. And I knew what I wanted but no existing rss client had the feeling I wanted. So I built Gorss. I use that every day as well. Https://github.com/lallassu/gorss

A friend and I always develop small scripts to generate stuff that's really boilerplatey in Android, basically writing text to files with node.

I've also made my own autoclicker for grindy Android games that otherwise detect in-OS clickers by basically using batch and adb to click certain spots randomly in a while loop.

Also a few batch scripts for a musician friend who's 0% technical to separate mp3 songs into instrument tracks (to rehearse and have fun) with spleeter by just dragging the file into the .bat.

Oh and a bunch of mini scripts to pull and merge stuff from one git branch to another and push it all (like dev to staging) to trigger a CI flow.

I hate blogging using markdown/wordpress so I built myself a blogging platform which lets me post via gmail. I've [Show HN]-ed it a few times now that I decided to productize it but it didn't get too many eyeballs.

The Perry Rhodan series was translated into English in the 1970s, but the series is very long and the translation stopped very soon. I can find Perry Rhodan ebooks and upload to Google Translate. However, converting the ebooks to text does not put them in a format useful for translating--the sentences are broken by newlines and there are specific problems like page numbers and the letter M embedded at a page break.

Thus, wrote a tool to convert such converted ebooks to have full sentences and to do a couple of other odd things so Google Translate and the particular ebook reader I am using handle them better.

I have several networking devices around the country with OpenWrt on them (for example, at my mom's house). They serve different needs, with different selections of packages installed, and are not of the same hardware, so keeping them up to date proved a hassle eventually. I chose to wrap some primitive Python around OpenWrt's excellent ImageBuilder that helps me keep a declarative build configuration around in an INI-style file, and (most of the time, when point releases are released) only dial up a single version number variable to rebuild all images in parallel. The flashing afterwards I haven't automated, but that might be too much of a footgun anyway.

If you feel like taking a look, here's the source: https://johannes.truschnigg.info/code/openwrt_autobuild/

---

While I was responsible for running the internal CAs at $prevjob, I wanted to give (human) users a convenient and secure means to generate and submit CSRs. I implemented a browser-based CSR generator based on the great work if https://pkijs.org - a demo variant of this internal portal is online at https://johannes.truschnigg.info/csr/ and might actually be of use to someone else :)

---

Several years ago also at $prevjob, I was looking for a reliable way to do PostgreSQL WAL archiving without the clunky shellscripts floating around in documentation and on Wikis, and implemented a little C program to do that job. While today you're probably using something like wal-g or other advanced tools that consume the WAL for replication and DR purposes, you may still want to have a program that does one thing, and one thing well, and that is making sure WAL segments get copied from location A to location B, without much overhead, period.

That would be it: https://johannes.truschnigg.info/code/pg_archive_wal_segment...

I wrote a small utility that helps me to kickstart writing blog posts.

https://github.com/scriptnull/sblog

(Been saving me a few minutes ever since)

I have a widget on my home screen that powers on my PC, syncs to latest, compiles my work code base and sends me a push notification when it's done (10-15 minutes most mornings). I use that time to make coffee and breakfast.

It's a flutter app using Firesbae for state and push notifications. I have a smart power strip, and my PC powers on when it received power, and logs in if the yubikey is attached to it (which I leave in at night). I have a golang service on my PC that runs in the background and listens to firebase for certain events and runs the commands and posts results back

SIM Notes, a wysiwyg markdown notes taking tool, based on Notational Velocity. It's a tool I literally tailored to my needs: 100% flat markdown files, in-place rendering, no structure, no tags, but a powerful and fast search. It's my own perfect zettelkasten.

Unfortunately I had to stop working on it when I had a burnout, so it's still buggy but good enough for me to use it every day.

I'm very slowly working on a v2, with a simple localhost daemon and no Electron.

https://github.com/scambier/SIM-Notes

A long time ago, before Spotify had support for multiple devices where one could act as a remote and control the other, I wrote a tool called Shpotify: https://github.com/hnarayanan/shpotify . It is a simple Bash/AppleScript.

The primary usecase for me was to SSH tunnel into a media centre Mac in my living room and control music on Spotify. I released it on GitHub and it has grown a lot in popularity amongst people who like to do a lot of their computing in the shell.

I made https://paymewith.xyz to share my social payments faster. Got tired of the “do you have Venmo/Square Cash/Paypal” dance.

I was frustrated with people missing emails/slack messages about GitHub pull requests.

I built a browser extension that shows a notification pop-up and updates the extension badge whenever you get a new pull request. Then I proceeded to convince my colleagues to use it.

For any Googlers out there, this is the same thing as CL Monitor, but for GitHub. I used to maintain CL Monitor back in the days (although I didn't invent it).

You can try it out at https://github.com/fwouts/prmonitor :)

I built Firn[1] a static site generator for my org-mode oriented wiki[2]. I needed a system that could nicely handle publishing public information, and keeping private information private. In addition, I wanted something that accumulated my clocked time in org mode so that I could see how much I have worked on each project.

[1] https://firn.theiceshelf.com/ [2] https://weakty.com/

Spotify playlists are great but I would like to be able to shuffle from a combination of them. Playlist folders do not cut it because then all combinations must form a tree. So I made a shell script to create those combined playlists [1]!

[1]: https://github.com/axelf4/nixos-config/blob/da60a70680984769...

I made a handful of ruby scripts to automate exporting subscription transaction data for my SaaS from Stripe, piping it into my accounting tool and reporting to the authorities. There's a script to validate that all paying customers are assigned a "VAT zone" (same country as me, EU or "rest of the world") and help me assign one if they don't (it's a command line tool that provides links to their email domain and Stripe customer data, to help me figure out where they are located). Then there's one to make sure I have a verified VAT number for everyone in a zone where that is a requirement (and warn me if I got a payment where the tax wasn't set up accordingly). One to pull all transactions from a given quarter, by default the last finished one. One to download invoice PDF's for all these transaction and upload them to my accounting tool. One to upload the rest of the transaction data to the accounting tool, categorizing things correctly by vat zone and linking up with the already uploaded PDFs. And finally one to generate a CSV of EU "reverse charge vat" customer transactions to be uploaded to the gov't for reporting purposes.

It started as a single script and has grown into a little suite of related scripts that function a bit like a pipeline, each operating on the same list of transaction data one after the other. All told I've probably spent a week coding and improving them, and they've certainly saved me several months of manual work in the last couple years.

I made Strainer, a CLI utility for finding duplicate lines in one or more files: https://github.com/brundonsmith/strainer/

My original use-case was looking for copypasta across a CSS project, but more recently I dug it back out to strip duplicate entries from a set of enormous EasyList (https://easylist.to/) files I was working with

I wrote a small script, executed with a cron job, which adjusts the color temperature of all my Philips Hue light bulbs throughout the day.

The Hue device bridges have a simple HTTP api available over the local network, and with a combination of curl and jq it was easy to retrieve the IDs of lights that are currently on, and then set their color temperature.

I've since moved the functionality into a small service I wrote in Clojure that runs on a Raspberry Pi, as part of an effort to consolidate a few different things under one roof.

Not sure it is a "tool", but I've created 2 iOS shortcuts to show QR codes for 2 use cases:

- let people connect to my wifi; - give my name + phone number to people (avoids spelling issues and typos).

I simply wrote some text corresponding to a wifi network and a vcard (see [0] for how this looks like) and show that text as QR code.

[0]: https://github.com/zxing/zxing/wiki/Barcode-Contents

Two that I can think of: - a Makefile to export and upload pico8 games to itch.io: https://github.com/tducasse/pico8-deploy - a tiny in memory database in JavaScript, that I used as a way to keep a global state server side in a multiplayer game https://github.com/tducasse/js-db

I wanted frontend debugging in prod so I've been halfway through building a source map injection browser extension for a while. The problem is that source map comments don't work well when the same artifact is deployed across prod and multiple staging environments. For each env at work we have different asset paths which need to be generated. Each server already serves up its source maps behind a firewall (for other reasons). The main work of the browser extension is to inject the source map dynamically at runtime when the page is loaded in the browser.

It can do this by taking a mapping of regex asset paths for each server in each env and the url of the source map location. Then it fetches the source maps internally, injects them using a SourceMap header with the chrome devtools network api, and that attaches the source maps in chrome's sources panel.

We used to get hit with production issues during oncall shifts more often. This came out of thinking about ways I could make debugging under pressure a bit easier for myself. If it helps I also automate common debugging steps with chrome snippets to save time.

We haven't been dealing with prod issues that need debugging for most of the last year so I haven't really needed it. It's not super hard to build though. If anyone wants to you should go for it!

I made a little script for quickly spinning up KVM virtual machines on my testing rig. It just grabs a minimal Ubuntu image, preseeds it with a ssh key, clones a VM on the default NAT network, and sets up the disk size/CPUs/memory allocation. It's not meant to replace orchestration or config management tools, just for quick and dirty VMs.

https://github.com/noahbailey/kvmgr

I wrote a GitHub Gist management experience for VS Code, since I wanted an extremely easy way to capture notes, docs and code snippets throughout the day: http://aka.ms/gistpad.

It completely transformed my behavior of writing and sharing, and I ended up expanding the experience to support GitHub repos as well, so that I could access and edit any of my “knowledge bases”, regardless how they’re stored in GitHub.

During covid, I wrote a tool that takes the avg daily infection rate in my county, makes some rough assumptions about incubation time, time-to-transmission, duration of contagion and asymptomatic rate, and tells me the probability of someone with covid having been in the supermarket down the street within the past few hours (based on capacity and traffic data of people in the market).

It wasn't usually very reassuring, but it felt better to see a number than just go in blind.

Sushi: Ruby script which generates a stub for a 1-file C project

https://gitlab.com/jjg/sushi

I've created Python Script for adding GPS coordinates to my photos. First version was using Google Takeout JSON file. Then later I've added Android App support (GPS Logger) and recently I've added support for hardware GPS watch that I've purchased on AliExpress. The code was little bit of a mess, I've improved it a bit after someone asked if can see the code. I've also added a License and README.

* https://github.com/jcubic/gps.py

I've also once wrote a tool that downloaded files from shared hosting sites. It was long ago when RapidShare was main site of this type. It was working with all the sites that was available back then and it was waiting before download the file. It was before captcha was invented. I was using router and dynamic IP and I've even added a function that was disconnecting/connecting the router to change IP when download the files.

The code is in Ruby and on GitHub I think this was one of my first project there https://github.com/jcubic/Downloader

The first one that comes to mind is a super simple (and hideous) app to stick images together in the layout of your multiple monitors in order to create a spanned wallpaper with a different image on each display. I created it ages ago when Electron was relatively new, and I still use it every month or so.

https://github.com/jacobmischka/wallpaper-adhesive

Wrote a VS Code extension to solve a very minor inconvenience. All it does is that it adds a shortcut to add the current date. Needed this as I use VS Code for journals, notes. Midway, I found another tool that already did the same, but was too excited to build my first extension, so did it anyways :) https://github.com/parth-paradkar/ClipDate

Program that interfaces AutoHotKey and youtube-dl so that I can easily play or download things with shortcuts. Haven't played a youtube video from the actual website in years (don't tell anyone).

Program that lets me keep track of the last time I did something (brush teeth, exercise, vacuum the floors, etc), which motivates me to do these things more regularly.

Program to convert between various units of bits, mostly so that I could do a calculation regarding download speeds.

Program to run programs without a shell, so that I could run certain commands on startup (it was faster to implement than to find an existing solution) [1].

Library to dump various useful information out of a Pokemon ROM, so that I could play the game more efficiently [2].

Playing card library, so that I could simulate certain solitaire games and figure out the chances of winning [3].

Program to quickly parse and generate markdown files from source code comments, existing solutions being too complex or not working quite the way I wanted [4]. This one ended up being a real winner, because it let me stop worrying about presentation and get back to writing code/documentation.

There's this sort of multi-tool I've been working on for game development on Roblox (very niche) [5]. A high-level overview is that it uses scripting to streamline certain workflows that would otherwise be tedious, such as parsing proprietary file formats, interacting with web APIs, or assembling a project into a final product. It's a winner because it lets me make even more tools for myself.

[1]: https://github.com/Anaminus/nosh

[2]: https://github.com/Anaminus/pkm

[3]: https://github.com/Anaminus/cards

[4]: https://github.com/Anaminus/qdoc

[5]: https://github.com/Anaminus/rbxmk

Firefox udpate script based around:

    /usr/bin/wget -nc --trust-server-names \
    'https://download.mozilla.org/?product=firefox-latest-ssl&os=linux64&lang=en-US'

which retrieves the latest release. After downloading, it's unpacked to a new directory named after the firefox version, under opt:

    FFFILE=`ls -tr ./firefox-*bz2 | tail -n 1`
    NEWFFDIR="/opt/"`echo $FFFILE | perl -pe 's/.*firefox-([0-9\.]+[0-9]).*/ff-$1/'`

and then linked to a standard place (/opt/firefox)

    /usr/bin/sudo /bin/ln -s $NEWFFDIR/firefox /opt/firefox-new
    /usr/bin/sudo /bin/mv -T /opt/firefox-new /opt/firefox

/usr/bin/firefox is already a link to /opt/firefox/firefox.

Old /opt/ff-XYZ dirs are culled manually.

This is easier for me than manual update from the browser, or relying on the distro's firefox updates. It also allows me a backout option while I acclimatise to new Firefox "features."

It took me about 30-40 manual updates before I got around to writing the script :)

A whole bunch of little things, mainly command line tools.

Most of them are open source and also have extensive documentation and a screencast video going over them.

Here's a few examples:

- https://github.com/nickjj/notes

- https://github.com/nickjj/invoice

- https://github.com/nickjj/wait-until

And a few recent scripts to optimize very specific workflows:

- https://nickjanetakis.com/blog/using-ffmpeg-to-get-an-mp3s-d...

- https://nickjanetakis.com/blog/a-shell-script-to-keep-a-bunc...

- https://nickjanetakis.com/blog/bash-aliases-to-prepare-recor...

I wrote a dictionary generator so I can get WiFi from business: back then I was too poor to pay for it.

I know now that there are many options out there, but I think my tool addressed my needs more efficiently.

I've noted that business in the town I lived back then used some sort of telephone number + name of their business combination for their wifi password.

The script actually gave me a 60% rate of success. Went through 4 years of college without contracting a ISP.

m4b-tool - merge, split and edit audio books (https://github.com/sandreas/m4b-tool/)

This one has become pretty popular in the meantime - did not expect that :-)

  ---

graft - file transfer utility with regex, mdns and sftp server (https://github.com/sandreas/graft/)

Designed to have tools like find and copy also on Windows - not maintained any more, since I found sfk, rclone and others...

  ---

look - a log file watcher (https://github.com/sandreas/look)

Designed to have tail on windows, not maintained any more, because its ready for my use case.

  --- 

pilabor - a hugo blog to manage my personal notes (https://pilabor.com)

Started as an experiment a few month ago for organizing my personal notes in a hugo project. Worked out pretty well so far.

I built a program that lets me parse the saved files from my camera (an old Nikon), including the read-only file attribute set using the camera UI, into Darktable. This also lets me assign ratings and manage files accordingly (i.e. 1 = delete both, 2 = keep jpg, 3/4/5 = keep both files and organize into folders according to priority). It's just a simple Python script but it has saved me so much time!

Brandon Sanderson, my favorite writer, keeps some progress bars in his website to let the fan know what he's working on. Unfortunately, those progress bars aren't visible in mobile devices. So I made a website for myself to keep tabs on them. And also for the other fans. Link: https://bransan.vercel.app

I made stylus to manage my home network with a Raspberry Pi. It requires barely and resources [!] any can manage anything that can be talked with via a shell script (including SNMP).

https://github.com/mmastrac/stylus

[!] I run it on a Pi0 and it takes negligible resources on that.

I have made this tool for myself: https://github.com/Otaka/LuaTextProcessor it is something like C preprocessor, but with macros defined in lua. I am using it for assembler development in assembler that does not support macros. With this tool I can use high level structures

Over time, I have automated 95% of the accounting of my companies. I started with a simple script that scraped the bank's website to create tasks in Asana for each entry in the statement, the task being "you need to do the accounting for X thing". So I could mark as complete each entry as I grabbed the corresponding invoice and filled the spreadsheet I later on send to our accountant.

Then I realized most of my invoices come by email, so I used Zapier and Gmail rules to find invoices and put them in a folder in Google Drive, which saved me more work.

This was very useful to never forget to fill something in the accounting anymore, but escalated quickly... Later on, I wrote a bunch of scripts that read invoices from Google Drive, extract the necessary information and place it in the spreadsheet for my accountant, rename the files to a standardized format and complete the Asana tasks automatically.

And there are more scripts, for example some services do not send you the invoice via email, but you can log in and download it, or the invoice information might be displayed on screen and if you want to keep it you need to print them out as PDF, so I wrote scripts for this.

All of this became an amorphous collection of scripts that are tailor-made for me and probably would be of no use to anybody else, but definitely made my life simpler. I know there are a bunch of SaaS services now that do this for you, but when I started they were not there and the ones I tried need more manual work than the solution I have today.

One little detail I noticed of my design and was totally accidental: since I made the scripts in steps and used Asana to keep track of which statement entries still needed attention, the "UI" is still Asana and the tasks can still be done manually. Therefore, my scripts do not need to cover all cases, which is great because it's not an all-or-nothing solution.

A basic résumé/CV generator out of JSON resume, it also supports inline SCSS: https://github.com/omninonsense/resume-stylist

I'd generally "print to PDF".it before sending it out. I was in the process of automating PDF generation when 1) I got hired and 2) Chrome was changing up the API in the next release so I just kinda... Lost motivation I guess, especially since I didn't need it anymore either.

https://github.com/omninonsense/spotlight-thief

This saves the windows spotlight images (on lock screen) to a folder that I use for randomised background images. I manually filter out the ones I dislike. It runs automatically on Linux (it's wrapped though).

Interesting that they're both in Ruby. I guess Ruby is my go-to scripting language, even though I usually never write Ruby. Maybe it's the language's ergonomics or something.

A small Todo git repo. Well, it started as a simple git repo with a text file, but now it has a web front end, and a lambda/cron thingie that can automatically add tasks based off a description of frequency. For me, having a todo task list I can use wherever I have a shell or browser means I'll actually use the dang thing. One of these days I'll clean up the code and put it somewhere public, I suspect others might find it useful.

The other thing I've done that I'm sure lots of people have done: A small git repo that has some random tools I've made from time to time. I put it in my path on any machine I use frequently, so I have my little toolbox handy. One of the tools in my toolbox spits out a command line to download and run any other tool without writing it to disk, or needing any credentials locally, so I can paste the runner on a machine I'm on, but don't want to copy all the tools or otherwise setup. That can be handy, and prevents me from polluting any machine I touch.

This is pretty trivial compared to some of the others, but I made a personal TV Guide for myself and my girlfriend using Trello and TVDB. (Screenshot below.) The purpose is to help keep track of what we're currently watching, since it's usually 5-10 things at once, and what we want to watch in the future, since that is almost infinite. Also, it helps keep track of shows that we set aside between seasons, but want to come back to (On Break).

The part I built (the part that isn't just Trello) is not strictly necessary, but it was fun to make and it makes the guide more fun to browse. When you drop a new title on the board, a script grabs the description and cover image from TVDB and adds them to the card. Searching by title isn't foolproof, so in case it gets it wrong, the script temporarily embeds the other search results in the description. Marking one with an asterisk will trigger a fix.

1. https://imgur.com/a/hZlg7Rl

I built this image differentiation tool to automate comparison of images generated by two different (one legacy, one replacement) image processing services: https://github.com/nicolashahn/diffimg

Seems to have become useful for a lot of other people, which I didn't really expect.

A couple of tools that may be useful:

Macs use a different UTF8 encoding for file names, that causes all sort of weirdness when sharing files with Linux / Windows machines, so I've made a tool to convert these: https://github.com/wazoox/utfmacmv

I was constantly in need of cleaning my ssh known hosts list, so I've made a small script around "ssh-keygen -R" that removes both the lines for the hostname and its IP: https://github.com/wazoox/khc/blob/master/khc

Also I've made a small CGI script running on my PC to scan the local network and identifying newly connected machines (because I'm building and testing servers): https://github.com/wazoox/PingScan

I have a lot of poorly engineered

    curl | grep | tr | awk 

pipes written into a loop in a bash script to scrape web pages and pull out text or data. I find if I'm just doing a one of, I can usually identify some feature of the html to pattern match one that lets me strip out the data in a very simple script and not have to use beautifulsoup etc.

That would be https://github.com/hbbio/build

The idea of build is not having to remember each command line to build some files.

Just put in comment inside each file how to build it (including all options and specifics) and run

build file.ext

It does not pollute directories as it does not require any file, unlike Makefiles.

I like to make my own things when I can, for me, that's a big part of being a computer user.

Hadware+Software - I built finalkey.net to manage my passwords, at the time I made, the mooltipass and other solutions were not yet available, and didn't fit my idea of what a hardware password manager should be.

Software - I made a tool for catching the video and audio coming out of my Ultimate64 Commodore 64. https://github.com/DusteDdk/u64view because none was available for Linux at the time.

Software - I wrote SDL-Ball because DX-Ball didn't work well in WINE.

Hardwaer+Software - I made a https://github.com/DusteDdk/RacingGpsTracker because I wanted to make GPS overlay for my dads road-racing videos. I later updated it to use the GPS data from the GoPro cameras when their GPS got fast enough.

Harware+Software - I made a controller for my wood-burning boiler because I disliked having to wait for it to heat up before I could set the "out of fuel" temperature limit. https://github.com/DusteDdk/boilerController

Software - I wrote a static image gallery generator for quickly making picture galleries for sharing with friends and family. https://github.com/DusteDdk/chromogen

I've made lots of other things, but then they're usually scripts or programs used once or twice for something specific and then thrown away.. Like the console-based ticker client I wrote for krakens api, to show me how poor dogecoin is making me.

I wrote a 10-line script to interactively query JSON documents using jq from vim in a tmux pane. Like jid[1], but better. Here it is:

  jq-repl () {
   local query_file json_file new_pane_height nodemon_cmd change_aucmd jq_args
   query_file=$(mktemp) 
   json_file=${query_file}.json 
   cat /dev/stdin > $json_file
   new_pane_height=5 
   jq_args="$@ -C -f $query_file $json_file" 
   nodemon_cmd="clear; jq $jq_args | less" 
   change_aucmd="au TextChanged,TextChangedI  write" 
   tmux split-window -l$new_pane_height $EDITOR -c "$change_aucmd" -c "set ft=jq" $query_file
   nodemon -q -d 0.3 -w $query_file -x "$nodemon_cmd"
  }

dependencies: vim, tmux, jq, nodemon

[1] https://github.com/simeji/jid

https://github.com/DontShaveTheYak/jenkins-std-lib A Jenkins shared library with a couple cool things like running GitHub Actions on Jenkins.

https://github.com/DontShaveTheYak/cloud-radar Unit and Functional testing of AWS Cloudformation templates. The unit testing part allows you to test locally without needing AWS creds.

https://github.com/DontShaveTheYak/sebs Stateful Elastic Block Storage was created so that you could make sure that a AWS ec2 instance always had the same EBS volume mounted to it. Really handy for a Ec2 instance in an ASG with a count of 1.

My own newsletter / database of tech links: https://bengtan.com/interesting-things

My own css colour selector/picker: https://bengtan.com/css-named-colours-picker/

My own anti-email-tracking service: https://bengtan.com/blog/email-cleaner-clean-tracking-links-... / https://bengtan.com/blog/email-untracker

My own accounting app: https://www.gigobooks.com/

I built up a web dev stack over the years while working on personal projects and client projects. First it was all together, but now it's separate libraries and a template app:

db: https://github.com/ferg1e/pajamaSQL

views: https://github.com/ferg1e/corn-wand

form validation: https://github.com/ferg1e/bouncers-book

misc: https://github.com/ferg1e/paper-cello

template user-based app: https://github.com/ferg1e/screen-name

I wrote hbr (handbrake runner) [0]. It takes a global config, a per-file config, and individual outfile sections then calls HandBrakeCLI to encode video. I use it to encode movies/series from optical media.

Additionally there is hbscan.py to generate a list of potential outfiles from handbrake's --scan argument. One day I'd like to integrate it with hbr (in C) using peg/leg [1]. Currently using pyparsing.

This is still a lot of manual work, but it saves doing it twice. When you find a mistake in an encode there's a log with the file, and it's easy to go back and modify the keyfile and re-encode it.

[0] https://github.com/epakai/hbr

[1] https://www.piumarta.com/software/peg/ (not mine)

I am building a remote job listing aggregator and have been working on it this entire year so far. I want one central place where I can view all listings by a certain company across all aggregators, or disable certain aggregators, etc.

I found it annoying to be browsing like 10 different top remote sites, but having no real way to filter out duplicates, keep track of the listing, save listings and progress them to custom stages a la kanban etc. I've put wayyyyy too much time into this but I'm excited to launch soon. Manually using excel is a PITA too.

I'm focusing really hard on accessibility, mobile UX, and in general usability. The backend is pretty beefy in that it essentially runs itself without any manual work on my part.

Some screenshots:

[0] https://i.imgur.com/PZMtTkq.png

[1] https://i.imgur.com/qfKAaZG.png

[2] https://i.imgur.com/ZDwEzS8.png

[3] https://i.imgur.com/NSreYUN.png

[4] https://i.imgur.com/XbFMQC0.png

[5] https://i.imgur.com/hcVSFSz.png

[6] https://i.imgur.com/tEoDukn.png

Another app I'm working on after this is one to introduce the git branching model to other types of work. Instead of commits/pr's+issues/branches, its tasks/conversations/topics. The idea is to get a birds eye view of what your team is working on and an easy way to publish your events to your team. Opening a PR, or an issue, or anything really takes many clicks and interactions and greatly disrupts my process so I built a native tool like spotlight where you can log a task, conversation, or start a new topic, in only two interactions.

Even as a developer there are many side things I'm doing in a given day that are not accurately reflected by git, and using slack/discord to publish "yesterday / today / tomorrow" is something that can definitely be easily automated.

I'm focusing on productivity tools that solve pains I've had at various points in my career.

Another one is a physical tool [0] to help people who do electronics and PCB design. I made this ruler that helps in designing new parts for PCB CAD softwares like KiCAD/Eagle. Then a few friends pumped me up and I got great feedback. So, I built a fabricated on with local manufacturer in Pune, India. Then someone was like you should sell them. So, I sold them via Tindie [1] and shared it with a lot of different people from around the world. I still use it. I am working on a V2 these days :D

[0] http://rohitg.in/2014/12/14/Tinker-Rule/ [1] http://rohitg.in/2016/01/01/MakersRule/

- Emacs mode for compilation bookmarks - A rss2maildir python script, that one never worked satisfactory due to atom/rss being shitty standards - A discord bot that gives daily reddit updates - Concerning bash a bookmark system for common directories, so I can do 'j dir' to jump to said dir.

20+ years ago I needed an invoicing program. So I wrote one Perl because I wanted to be cross-platform and I wanted to learn Perl. I ported it to Python last year. The program is dumb as a rock, but almost as stable.

I also wrote a super-simple backup script (python) that backs up my filesystem the way I want. It has a TCL/TK front end with data-driven actions (button, source and destination). It's 'manual', but my external drives are air-gapped. It writes a report with various statistics.

The way these things boost the quality of my life is that backups and invoicing are "mission-critical operations". In the event of a disaster, I could port these operations to any computer with a thumb drive. The only thing I need to install is an interpreter. My backup machine (if I even need one) can have a different OS.

Oooh, so many: - finance tracker for my wife and I when saving for our first house. JQuery and PHP, my first “real project” - had a great domain name: spentby.me - stock/production management script in Python for my business that I eventually rewrote and released as my first iPhone app (StockControllerapp.com - still sells a few copies a week after 5 years) - stocks/shares analyser script in NodeJS to show industry and company weighting’s to show if we are over indexed on a holding/sector - Instagram post creator in React so I can make educational coding carousels in the style my account has without having to faff about in figma

Pretty much everything I build is to solve a problem I have for myself and I just don’t like the existing options (I always looks first and if I find something I like I use that, if not I roll my own)

https://apps.bydav.in

ssl is sketchy working on some of these because of gitlab and or cloudflare settings.

The one I use everyday is a html javascript form hosted on gutlab pages and sending data to google sheet via apps script, to record my timesheet data.

Since coding, I have used the gotp app, which is Google TOTP impory export & backup before Google Auth itself implemented. Still, their way is to start from scratch only, whereas mine one can be used to add accounts. https://spa.bydav.in/otp.html

I used a mix of gmail filters, app script & sheets to download every email I received as eml file & save it in drive folder named as year, & eml named as yyyy mm dd hh mm ss ttt nn subject.eml

I wrote a bot for GitLab that can do a few different things:

* Nag (Comment) on Merge Requests to tie it to proper release milestones and labels, something that is easily forgotten, or simply ignored by their UI due to the "never consistency" method of Javascript frontend.

* Create ChangeLogs from a Milestone, by traversing all the MR's merged during the time window, or associated with the milestone.

* Generate Wiki pages with above ChangeLog, as well as generating markdown templates with release notes as well

* Tag projects for release, automatically using above ChangeLog to generate a correct list of changes that has happened.

All this assumes a certain workflow, in our case time-based releases where multiple projects get tagged regularly for release, and development for a release is tracked in a milestone.

The tool is FLOSS, but it's fairly specific to my usecase.

I built a redis AOF rewriting toolchain to undelete keys at specific points in time because I was working with people who picked a storage engine without consistency guarantees without understanding the consequences. The tool will trace the lifecycle of a key through the AOF and all events attached to it so you can pick an event to “undo”. The output is a bunch of commands to recreate the key in the state you need it in.

I’m not publishing the source because it’s extremely dangerous and not very well tested. In the wrong (or right but with misunderstood intention) hands it can make your day worse.

It works by iterating through the AOF, filtering all commands related to the interesting key and replaying all commands except matching ones into a standalone instance of redis. Then it dumps the key that is left.

I built a tool (framework if you will) that helps me build comparison websites (1 on 1 comparison) rapidly, it's been quite useful initially for ourselves of course, but later on for others. I'm now building out an "imperium" of comparison sites - hopyfully worthy of a side-hustle style income next year.

The way it works is you enter some "categories", then when you have time you research one of the providers, add that yaml file, and that's it. Automatically deploys and updates everything. No database or complicated things, just simple feature comparisons.

For anyone interested, you can see a version of it at https://www.srvrlss.io

I made https://multipreview.com to improve my twitter feed.

When I write a blog post I typically share it 2 or 3 times to highlight different parts. But in the twitter feed, there's always the same image so it looks pretty bad/boring.

With multipreview I generate a link with a custom image, so I can share the same article but the previews always look different.

It's actually a hack I tested on a weekend (return a small html page with custom meta tags + immediate redirect to the destination link). It worked in the sense that it's previewed as I expected on twitter/facebook/linkedin. So I started using it here and there, showed it to a couple friends and eventually made it into a small saas.

I built PACT [1] to allow me to partition my CPU for different processes.

I built SASRip [2] and MediaReaper [3] to download media from the internet to better share with my friends.

I also have a myriad of small tools and scripts to automate most of my work, whatever that work is. I've done many different jobs and I've automated a thing or two in all of them. ----

[1]: https://github.com/sas41/ProcessAffinityControlTool [2]: https://sasrip.cf/ [3]: https://sasrip.cf/Home/MediaReaper

I made a tool that takes a list of timestamps as input and outputs a histogram of the count of those timestamps grouped into bins of any size (default is 1 hour):

https://gist.github.com/lelandbatey/58330f13a02e7b5a0af179d5...

I've found this to be a HUGE help, as I frequently have data from all kinds of sources and I want to be able to ask questions like:

"When did records matching this query start getting created over the last month?"

"Have there been any big fluctuations in the trends of when these records are deleted?"

On and on. It's an incredibly versatile tool to have access to and I was SHOCKED that there weren't existing tools for this case.

There’s a program that reads the kindle clippings file and renders one random quote as my wallpaper, it runs on startup. I ended up liking it way more than I thought I would.

There's also a little website blocker that's just a list of buttons with preset websites to block and a delay for unblock, all that I tried from the web came with so much jank, complications and payments, so that's the reason for that. Also, very much worth it, a lot of the addiction in social media is really low strength, so tiny barriers like this or a chrome extension that disables yt recommendations have been very effective for me in reducing unintended usage.

A night light extension for windows that I made when microsoft's one stopped working, and I couldn't find a way to make software brightness and night light programs work well together. Both were modifying the gamma ramp, which would cause flickering in between each program's settings. I expanded it to handle monitors settings (contrast, bg) and multi monitors. There was also an attempt in having a whitelist for when specific processes were in the foreground and taking more than x% of screen space, but at the time it was kinda of a pain to implement and manual control worked fine.

An image viewer that was an experimental frameless, zoom-increases-the-window-size-when-possible. One thing that surprised me about it at the time was how much faster it was than m$'s w10 default image viewer, especially in image switching. I was using stb_image to load the different formats, but there was no attempt at optimization whatsoever.

I'm making a weight log app right now, but that's more of a "I mostly do cpp let's try doing something outside my normal programming environment". Completely gave up hope of programming this thing at a fast pace, the friction from switching environment/languages/approaches is very, very, very high. It seems now i’m in the tail end of having all the features in, some stuff takes a long time to load, like the camera module. I have no idea how I’m going to make that thing go fast, but ugh it’s shaping up okay ¯\_(ツ)_/¯.

As part of my job, I report a lot of phishing sites. This gets very annoying very quickly.

As well as reporting to SafeBrowsing, etc. for each site you also need to look up the domain registrar and hosting provider (via WHOIS) and email them.

Rather than do this manually every time, I wrote a small CLI to automate the lookups and even open pre-templated emails: https://github.com/bradleyjkemp/abwhose

I'm now redoing this as a web app so that I can do the entire reporting process without leaving the browser: https://phish.report

Kinda fun trying to "speedrun" the process down to as few clicks as possible.

I got tired of firing up an image editor every time to create a simple open-graph/social image for my blog posts and built https://thumbnail.ai

It's been a great time saver and a handful of people use it daily.

I created this tool for fun to experiment with my raspberry pi

Its a tool that allows you to run server commands via text messages

https://github.com/mtdevss/server-text

Its a fun program to play around with

I wanted a way to keep track of my expenses so I built a mobile app in Flutter to do just that. App data is stored on device, no cloud, no tracking, no third parties, and I use SQLite files for storage and export. I made it available for free:

- for Android (https://play.google.com/store/apps/details?id=ro.lansator.ba...)

- iOS (https://apps.apple.com/us/app/banii-mei/id1436417739)

Great experience learning Flutter and publishing the app in both stores.

I made an editor for markdown front matter. Useful if you're building sites using Jekyll and similar.

https://github.com/ognjenio/front-matter-editor

I bundled together a small collection of sysadmin/scripting-tools here:

https://github.com/skx/sysbox

Those are probably amongst the things that I use most often which are non-standard.

I made the "little library helper", lhelper[1] in short to help me compile C/C++ libraries on Windows for my applications, using gcc or clang. Later it turned out so nice and useful that I got it working also on macOS and linux.

I made it out of despair because compiling stuff on Windows was so painful. Now with lhelper it is a pleasure.

It contains recipes for downloading and building libraries and install them in a virtual environment with only a few, useful, options.

In some way the fact that people love and use for header-only libraries is because they don't have lhelper.

[1] https://github.com/franko/lhelper

I made an iOS client for HN 3 years ago as I spent a lot of time reading and wanted features like notification for replies, dark theme, swipe to vote/favourite etc. It's been out for 3 years now and fully featured plus iPad and MacOS support too. Recently, I switched from iPhone to Android as the new iPhones were too expensive. So now I am working on the Android version of the app too (which is pretty new to me as I am just learning Kotlin).

https://apps.apple.com/ca/app/hack-for-hacker-news-developer...

- A simple php script that emails me daily asking "what did you do yesterday" and logs my replies (using Mailgun's free threshold). I've now had a diary for 10 years. - A simple php script to log the dates of mp3's I add to a certain folder, which helps me organize my monthly radio show (So I'm sure I play the new music I get). - A WordPress install to store recipes I like. - A small browse extension + php api to catalog social accounts I visit often. I often mention the same people in my twitter, facebook, instagram posts (I review their music), so I don't have to look up their multiple accounts every time.

I run an e-commerce site with our own manufacturing and fulfillment. I created a small program to sort shipping labels into piles based on our needs. We used to do this sorting by hand. It's not much but saves 30min a day, 6 days a week.

I keep on bookmarking things and those get lost in the huge pile I already have. So I ended up doing this: Created a Google form which takes two inputs: URL I want to save, and a comma separated list of tags. Then when it's submitted, an apps script gets triggered which inserts the URL+list of tags as array into mongo dB. Then I query for URLs containing atleast one of the tag of form submission, and email myself those URLs saying hey you previously have saved these related links, check if you wanna read them. It helps me to easily query whenever I want to see things I've saved for a particular topic/tag

I've been working on a todo app built on todo.txt. It's a fork of another app, Todour, which I've heavily enhanced. It's a work in progress, it is ugly but very functional.

https://github.com/shawnaxsom/inizio

Being an engineering manager, a good todo system is a must. I need to be able to write to it quickly in an organized manner. I need it to filter quickly, being able to tell it "Show me all of my highest priority tasks that don't have anything to do with person XYZ who is out-of-office, hide learning tasks".

I recently wrote a shell script bound to a keyboard shortcut, that pops up a window with a text input field that accepts LaTeX input, and immediately converts it to a JPG that is then copied to the clipboard. Super useful.

I built https://sumi.news so I could read RSS, Twitter, and newsletters peacefully. It started as a local app to fetch RSS, and transitioned to a web app to enable reading newsletters. It’s written in Haskell and hosted on Linode.

I also wrote my own classless UI library. I can drop in a single style sheet and write plain HTML, no classes or anything, and get beautiful cross-platform UI that is accessible and functional out-of-the-box. I use this for a lot of my projects. I plan on polishing it, open-sourcing it, and selling it in the future.

https://day1of.com

I got tired of having to think with date math, specifically determining the difference between "how many days between these dates" and "this is day x of span y", so I just made a tool specifically for that 2nd case.

Eg, in my journal entries I make a note of which day of covid lockdown it is, by bookmarking this on my phone home screen:

https://day1of.com/?startDate=2020-03-12&condition=COVID19+L...

Wrote this for diagnosing OOMs on our Hadoop cluster at work: https://github.com/mbrtargeting/oom-monitor

1. A design system, to create web sites on the fly.

2. A content-as-code framework, to help me writing complex articles, mini-books. The ideas are visualized as a directed graph, so I’m sure I’m sticking to them, and the result is complete.

3. A color scheme generator for web sites, to help me creating themes with accessible typography.

4. Gravity point calculator, to help me localize the focus point of a web page / slide, to make sure the message is delivered.

5. Art directed images, displaying the same image in portrait/landscape, depending on the device/orientation.

6. Hand made web decorative elements, to make uniquely looking web sites.

I wrote Unix/bash utility as a repository that when cloned into your `.config` directory makes it very simple to isolate available environment/functions/scripts/config based on the current directory you are in. The resulting config that you make is stored centrally in your .config directory but is only active in the corresponding file path (or globally, depending on the use case). It's been very useful.

https://github.com/jjorissen52/shell-env

Hope this fits the request, I created two simple tools recently:

- The Simple Password Manager (https://www.tspm.ch), a "password manager" that generates a password from an easy to remember passphrase. I created that for myself and to make my friends stop using the same password everywhere.

- Pokerplan (https://www.pokerplan.ch/), a scrum Poker tool that I made for me and my co-workers for our scrum pokers during the pandemic.

Back in 2006 I had a side job as an IT journalist. I wanted to draft my articles while away from the computer on the Pocket PC, as laptops were really out of my reach, and back in the day the localized input methods (touchscreen keyboards) were paid and expensive apps.

I ended up with a text editor supporting various formats and inpit languages, implemented in quite dreadful verbose C#, as I didn’t know any better.

https://sourceforge.net/projects/ppc-edit/

A lot of the tools now in fuchsias fx started life as personal standalone scripts later exported to the team. Nowadays contrib contains tons more, some of which also started similarly. These all now have a long history from many contributors. You may be able to glean the historical process stuff from the git history.

https://cs.opensource.google/fuchsia/fuchsia/+/main:tools/de...

I've been leaning pretty heavily on Discord during COVID to stay in touch with friends. I play D&D with some of them and wrote a Discord bot for dice-rolling since we already used Discord for audio/video during our sessions. It's not very complex, but it was good practice for using the Discord bot API, and I can host it on my Raspberry Pi in my apartment.

https://github.com/micahpress/discord-dice-roller

I usually print books I buy as PDFs and then bind them myself as well. The process is very nice and meditative. So, I wrote this script[0] that converts a pdf in seams of 16 pages that can be printed directly in correct order on a normal printer. So, I can just send the PDF to a printer without worrying about anything and fold and bind them later by hand.

[0] : http://rohitg.in/2018/05/30/Spreadmaker/

A tool that could do a bidirectional sync over FTP or SFTP. Think of it as similar to Unison[1] without needing the client running on each end.

I needed it at the time to synchronise a local copy of a web-site with the remote web-hosting space. Other people were also updating the site, so I needed to be able to pull down changes from the remote side as well as push my local changes up.

[1] https://www.cis.upenn.edu/~bcpierce/unison/

https://codingfriends.github.io/Tincta/

While studying a friend and I used a text editor called Smultron for all our VHDL and HTML/JS scripting. The developer stopped supporting it for a while and we got annoyed by unfixed bugs. In the end we missed having this little, easy to use tool so much that we wrote Tincta. It was heavily inspired by it. It doesn’t get enough love nowadays but I still use it for short notes.

I wrote a program to help me archive my google mail. You can query it like a database (group by senders, subjects, etc.) and perform the archive operation.

Useful for when the inbox gets to 1k unread messages.

A few months ago I wrote (and expanded over time) two simple scripts for note-taking and time tracking at work (because our official time tracking tool is kinda lackluster). They're really nothing special, just editing some Markdown files stuck in a Git repo, but they're a vital part of my daily toolbox.

I've pulled them out into a separate repo and published them here: https://github.com/T0astBread/sticky

I frequently needed to look up x records by id/name/etc. I knew the values, but needed to format them to work in SQL! I took my list and copied it in a text editor and had to run multiple regex commands to format the list so it could be used in SQL, ie. ('value1', 'value2', 'etc').

I got tired of this and built a VSCode extension: https://github.com/reZach/listtosql

I wrote a small PHP to present urls from a text file as RSS. I use this to mass-add torrent files to rutorrent. For each case, I just have to prepare the text file, which is usually done with a small javascript in the browser, then this tool, and rutorrent does the rest.

I also write a small program whenever I'd like to watch a product's stock or availability. This is also case specific, usually a small PHP snippet with some browser-exported cUrl command and parsing the HTML or API response.

I wrote several tools for myself, the longer really still useful are:

* a voip callback daemon I trigger with Telegram: with a "call Tom" message to its Telegram Bot, the daemon call my phone and call Tom, and connect us together. I use it save phone costs (daemon chooses the best voip account depending on both the country I am calling and receiving calls), especially while anchoring where internet is too slow for direct voip calls.

* a small bash script for wireguard (quickly switch to a vpn profile)

I've been learning rust recently and trying to make a few CLIs/TUIs for simple tasks.

I have a simple CLI for handling the `$PATH` environment variable [0].

And I have a simple TUI for keeping track of financial statements for various accounts [1].

[0]: https://github.com/jrhawley/pad-path

[1]: https://github.com/jrhawley/quill

ttymidi http://www.varal.org/ttymidi/ Written around 2004 to allow me to make custom MIDI devices with Arduinos.

NiftyPlayer http://www.varal.org/niftyplayer/ Made in 2000ish to play mp3s on a friend's website.

Cardapio https://launchpad.net/cardapio Made around 2010 to replace the app menu in Gnome to support search, ability to navigate folders, and plugins.

TomatoInTheSky http://tomatointhesky.com/ Pomodoro timer with the ability to pause (which goes against the technique). Made in 2010 for my wife to study for dentistry classes while working in hospice care.

FiveHeadlines http://fiveheadlines.com Reddit reader that pulls 5 headlines from my favorite news subreddits, so I don't browse Reddit for too long. Made around 2014.

And now my joint project with some friends is where I work every day! Started in 2018 https://streamlit.io

At my company we used to pass around a single wildcard cert for our corporate domain. All servers, including many internal servers, all had the same long lived cert.

I made a tool to make it easy for us to deploy Let’s Encrypt certs for internal only servers that would normally not be able to do an http challenge against LE.

https://github.com/Imageware/TLSential

One of the projects im most proud of. :)

Wrote some tools to convert a bunch of kanji (japanese, originally chinese characters) stroke diagram (diagram on how to write the character) csv's I got from some open github database into png's with nice colors per stroke. Which I then added to a kanji anki deck for learning japanese. Maybe not quite the kind of thing you were asking for since it is not a tool I run regularly, cause you only run it once. But I use the results on a daily basis.

I built a music "scrobbling" program called rescrobbled to submit music I listen to Last.fm. I was sharing a Spotify account so I couldn't use Last.fm's Spotify integration -- which is pretty bad anyway, in my experience. Rescrobbled has served me well (and a few other people too, apparently).

https://github.com/InputUsername/rescrobbled

I made https://eclect.us/ it's basically a collection of scripts ran with jenkins that summarizes SEC 10-Q and 10-Ks as they're published using BERT and decision trees trained on the performance of the underlying stock after a filing.

There are other services that do this better but I just wanted something clean that didn't have a cramped UI, and wasn't a paid service.

Skyscraper, my scraping and restructuring framework: https://github.com/nathell/skyscraper

I’ve used it to build datasets for various research purposes, and also an archive tool for the now-extinct soup.io: https://github.com/nathell/soupscraper

I wrote a free Mac app to OCR any text on screen[1].

macOCR is a command line app that enables you to turn any text on your screen into text on your clipboard. When you envoke the ocr command, a "screen capture" like cursor is shown. Any text within the bounds will be converted to text.

You could invoke the app using the likes of Alfred.app, LaunchBar, Hammerspoon, Quicksilver, Raycast etc.

  [1] https://github.com/schappim/macOCR

Approximately a year ago I wrote my first program in Rust as an introductory project to extract assets from Renpy archive files [1]. Basically it’s for ripping assets [2].

[1]: https://gitlab.com/L0g4n/unrpa_rs [2]: https://blog.l0g4n.me/unrpa-rs/

I was too lazy to learn how to use a packager so I built one in Node. It's dead simple and lacks features but works great.

On my website: https://benergize.com/software/pyleon/ On git:https://github.com/benergize/pyleon

I wrote this (at work) to update versions in our projects from one place, and even partial versions. Saves me some headache and mental space every time. I know there are competitors but none I found was just simple, everything else was bloated with Git-integration or regex search instead.

https://gitlab.com/MaxIV/app-maxiv-semver

I built a Reddit desktop client called `rdddeck`. It is compact like Tweetdecks, and supports multi-accounts. It gives me an overview of all my subs at a glance.

It also works on mobile device, and looks amazing on an iPad.

- https://rdddeck.com

Motivation: I dislike Reddit's modern UX. It is difficult to navigate, large negative spaces (wasteful), pop-up like behavior when opening a discussion, etc.

Built https://addue.com for conversion tracking and traffic routing purposes for my ad agency. Later decided to make it into a SaaS tool.

Similarly I built https://Classient.com to take class bookings online for some classes my wife was teaching at the time. Made it into a SaaS tool this year.

I wrote my own CSS reset stylesheet because I was tired of copying over the same additions to normalize.css on every new project and wanted to install it directly from npm. Basically it does browser style normalizing + reseting/removing (almost) all default styles.

https://github.com/nicolas-cusan/destyle.css

I wrote a python script that returns annotated PDFs of submitted homework via outlook to all students.

My workflow is to grade on my iPad, Airdrop the files to my computer, then I can run the script that matches emails and PDFs and sends them out. Before I used to compose and send emails manually, but that took forever.

Now I need to figure out how to scan my inbox for submissions and send them to the iPad automatically (anyone have an idea?)

My favorite is https://calcula.tech which I made to help with my physics and chemistry homework. I have a few other users, mostly friends from school AFAIK, but I'm hoping that it can become more useful for more people. I wrote the main interpreter in Rust mostly from scratch, and the site is built with elixir Phoenix and alpineJS.

I have a couple of projects that I’ve used over the years. My favourite is probably Architect, which is yet another Arch installer configured with a little bit of YAML and all in bash

https://github.com/jnsgruk/architect

It supports a couple of different options for partitioning, encryption, flicker free boot and some other nice bits :)

I spent untold number of hours in my doctors waiting room watching Judge Judy, so I built this app which could tell me where I am in the queue, so I can go out sit in a cafe. https://youtu.be/RZ6vnLXtIcY I tried to sell this to my doctor but he didnt buy it. If anyone has any use for it, let me know.

I built entire service [0], because I wanted to chat in matrix (protocol [1]). It's quite hard to selfhost it properly, so I ended with lots of automatization, based on open source stack.

Now I can setup a homeserver in ~20 minutes with lots of additions and customizations.

[0] https://etke.cc

[1] https://matrix.org

Near our work there is a single public tennis court that in normal (pre pandemic) summers is heavily contested for bookings. So I wrote a script to book in whatever set of sessions me and my colleagues wanted to play for the following week. It was pretty consistent, would still miss a few though - other people were either staying up to midnight, or they'd written their own bot!

I created bunch of scripts that allows me to spin up a full 3 node mongo server with interfaces and webui. Creates daemons to monitor everything and restart when crashing, auto-renews certificate for lets-encypt and spins up a json server with basic crud apis ... starting a new project takes 30 mins but it saves me sooo much time debugging why things are not coming up as i wanted

Despite its numerous shortcomings this dictionary bash script was pretty useful to me at a recent abbreviation-heavy gig:

https://github.com/dcminter/define/blob/master/define

I am pleased with the utility:simplicity ratio but slightly ashamed of its limitations.

I was frustrated with how slow the Apple Notes app was, so I made k for myself (https://getk.com). k launches instantly to your keyboard and camera, so you can take notes and photos in no time. I use it instead of Notes and Camera.

It's 100% Swift and collects no data at all. k is my 3rd app and it took me 2 month to build

I wrote a wiki server to store important notes:

https://gitlab.com/moasdawiki/moasdawiki-server

I also wrote a Kanban tool to organize my personal tasks at work:

https://gitlab.com/moasda/task-organizer

A tool that will read your Java REST endpoints, and make TypeScript interfaces and invocation functions, so you can pretend your React front-end is using DCE again like it's 1999.

https://github.com/BlueCircleSoftware/bluecircle-json-interf...

"backupper" - my system of local backups for my raspberry pis. it still needs some refining: https://gist.github.com/smcalilly/79b52fc54aa932cc6b222c6702...

it was mainly a project to learn more about linux stuff, seems a bit overcomplicated

I had one a number of years back when I was writing an iPhone app to be whitelabeled for various clients, that would overlay a "Beta" banner on their icons for beta releases. I wrote it for fun (and so I could easily differentiate between beta and full release versions on my own device), and right as I was finished, it ended becoming a client request anyway.

https://github.com/mterron/swuniq

Like uniq but works on unsorted input to be used as a pipe filter with constant memory usage.

Feels like this should exist before I made it but all the options that I could find had unbounded memory requirements. I use it in long running pipelines all the time.

https://www.npmjs.com/package/bebusy

Seven years ago I needed time for finishing a school project and wanted to look busy at work. The packages prints random messages to terminal, so you look like you are are in middle of some deployment job or npm install.

Still works as far as I know.

I made this [1] little thing just to change a Commodor Amiga emulator opacity so i could copy some images in Deluxe Paint II or even Deluxe Paint in DOSBox.

Made it in like 20 minutes for that absolutely weird use case. Almost never used it again.

[1] https://github.com/manuk3r/procopac

Got tired of having to pause/resume media while watching food, made a script to automatically pause/resume media if I'm not focusing on the screen. https://github.com/amar-laksh/focusTV (the code was not great but it works)

I had enough of mounting and decrypting devices before and after doing offline backups, so I ended up writing a tool to automate "acquire and release" tasks that I'm a bit too proud of:

https://dcz_self.gitlab.io/posts/blossom/

When tasked to do some e-mail template development at work without access to a mail server I developed a small cli tool[1] that converts HTML to EML so I could send it as an attachment to the test devices.

[1]: https://github.com/rootdevelop/html2eml

We made this app for our projects and then decided to put it on sale as a generic app with source code of mobile app along with Adruino/ESP firmware:

https://orison.biz/projects/flutter-esp8266-iot-starter-kit/

Wrote a command-line tool called Erudite to download articles from Instapaper or Pocket, convert them to an appropriate format such as EPUB or MOBI, and add them to your Calibre ebook library.

https://evanmclean.com/software/erudite/

Really simple mouse gestures for macOS (after xGestures became unreliable for me). Right-drag to the left to go back, or to the right to go forward. Only a few hundred lines of Objective-C.

Then I cleaned it up a bit and submitted it to the Mac App Store, and was pleasantly surprised it was approved. I think it’s the only mouse gestures app on there.

I was obsessed with AARON a procedural artwork generator featuring humans, plants and paintings. Made a viewer to read, draw and export its image files http://xosh.org/Kurzweil-CyberArt-AARON-Image-Viewer/

I made a powershell script that automatically creates zoom accounts from a excel sheet. It also sets their profile image.

I built this web best practices checker (e.g. looks for broken links, missing titles, bad cache settings, insecure forms) that checks multiple pages at a time:

https://www.checkbot.io

I built it to scratch my own itch while doing web development work and spun it into a paid product.

cninja, to enforce better CMake defaults, manage various configurations for CMake buildsystems and easily generate toolchains with a set of configurations / linker options / etc.

=> https://github.com/jcelerier/cninja

I like traveling but I always feel like I do it inefficiently or I skip out on smaller towns because Google doesn't show them unless you zoom in far enough so I built this

https://unli.xyz/city/calc/

I've built a tiny dependency installer targeted at old systems / clusters where you need to bootstrap modern libraries and tools from an old GCC.

It's very small, just a few lines of Bash.

https://github.com/W4RH4WK/DIFAS

I bought a Remarkable2 tablet, and love it. Unfortunately, there is no way to easily consume email on it (email newsletters, which don't require any responses). I built a service that gives me a unique email I can sign up with, which then packages the email body into an epub that I can read.

I'm in the middle of building an ML model to make it so I don't have to use green screen anymore when making my short films! It's based off of some recent research at the University of Washington, pretty fun stuff. Maybe 75% complete, starting to get semi-reasonable results finally.

I wrote a python script running on a raspberrypi: would listen for a button press on a sheet fed scanner, make a PDF and send to the destination of my choice.

I could have bought a fancier internet connected scanner but that would have been wasteful.

Does this fall in the tools category? Or it's more automation than tools?

I got tired of the terrible split screen markdown note taking apps. So built myself bangle.io [1] , a WYSIWYG note taking web app that is completely local and saves notes directly in markdown format in your hard drive.

[1]: https://bangle.io

I have made https://editcsvonline.com, a simple tool to edit CSV files without the need for Excel or Google Sheets. It's a free tool that anyone can use, meant to promote my Excel-like product DataGridXL.

I found myself ending up with 50+ browser tabs regularly - full of tabs I want to read later. So I made https://closetab.email that lets me mark and close those tabs. They all get delivered to my inbox every monday.

A static blog generator [0] which generates https://plurrrr.com/ for me.

[0]https://github.com/john-bokma/tumblelog

Drove / automated a currency trading application using https://www.autohotkey.com/

The amount of error handling probably made it more worthwhile to learn the actual automation language, but it worked.

I made https://xbm.jazzychad.net as a simple online XBM image editor for use in various Arduino projects that use those little oled displays. It was also an excuse to learn React a few years ago.

I don't make tools I write rubbish scripts that do my job for me. My job involves filling crappy designed forms on worse designed systems that seem to be designed for maximum clicks and slowness.

I'm not allowed to install anything so thank god for autohotkey!

I did a calculator TUI to visualize binary and hex while developing an emulator :) https://github.com/alt-romes/programmer-calculator

I built an online flashcard platform (memordo.com) which support live-rendering of latex and codeblocks, and custom study/repetition schedules. Memordo has totally replaced Anki for me, which is nice to build something you actually prefer to use.

I build a cli music player that can handle both local mp3s and Spotify tracks in the same playlist, because I wanted that. I also recently built a tool to help me keep track of my books (what I own, what I want to read, what I've borrowed, etc).

I wrote `redis-del` [0] years ago while prototyping a queue for a web app forever ago. Wildcard redis delete. Still use it.

[0] https://github.com/e9labs/redis-del

calculate movie rating from imdb review votes, I would like to think that is more sane than blackbox rating [1]

[1]: https://github.com/diimdeep/sane_imdb_rating

> diim

I wrote a script that would build a list of printer brands and their corresponding toners. https://github.com/kurcz/PrinterTonerDB

I made a command line tool in Golang to get your current IP address along with the Google Maps link to the exact GPS

https://github.com/claytonblythe/myip

I have an augmentation of clickup via their api which lets me report in different ways on subcontractors and tasks/projects/clients over different time periods and calculate overall/historical profitability. Works quite nice :)

I needed some calipers that were large enough for a human head. Fairly expensive online, especially for a one use item. So I reviewed some classic manual types and designed my own 3D model and printed them out for cents vs lots of dollars.

I made my own dotfile manager: https://github.com/SuperCuber/dotter . With time, at least a couple other people started using it :D

I build a tool which retrieves my bank transactions hourly, puts them into a SQLite, does some magic (deduplication, cleanup etc.), maps categories (which are hosted in Airtable) via Keyword search and then pushes them all to YNAB

gwebp can recursively convert images in the specified directory into webp of the same name. https://github.com/linehk/gwebp

Not my tools, but been following 100r long enough to know why they build their own tools: https://100r.co/site/home.html

Small application to get listing of torrents from IMDB's watch list: https://github.com/navyad/moviematch

While in a long distance relationship with a med student I once made an email preprocessor that would look up every word longer than 7 characters in a medical dictionary and add a hover over tool tip for any matches.

https://quicktimetrack.com/ I made this tool to track my working time as a freelance, Im the only one to use it

Espial — an open-source, web-based bookmarking server https://github.com/jonschoning/espial

I wanted a way to compare fonts easily and quickly so I built Pair & Compare [1].

[1]: https://www.pairandcompare.net/

Romylms.com - I hated training people in the same material over and over. Now I train once and record it and send all future people to watch that recording and take a quiz. 100+ courses now.

I wrote Piku (https://github.com/piku) to do all of my deployments. Easily the most bang for LOC I ever did.

My own code generator "obviously" :) https://github.com/mintyPT/sigla

I wrote a simple app to send interesting articles and web pages to my email inbox - https://www.emailthis.me

Better habit support for Todoist: https://habitsfortodoist.com/ and https://github.com/travisjungroth/habits-for-todoist

Algorithm practice: https://github.com/travisjungroth/algo-drills

A tiny script that adds articles I want to see again onto my todo list: https://github.com/travisjungroth/boomerang/blob/master/boom...

A service i made to track my working time https://time-tracker.ivarlovlie.no

Almost trivial, but I built a little jig out of sheet metal that came with breadboard to cut hookup wire exactly the length I needed it. Saves tons of time.

Last year I was learning Node/React, and built a Certification tracker with the MERN framework to track certification renewal dates

1. Trading automation platform (with a decent GUI)

2. Dropbox like command line functions for single user repos to be auto-synced across multiple devices

I wrote a man in the middle proxy last week(for debugging) because mitmproxy assumes http/s, and I want to monitor a tcp stream.

http://hndeck.sawirstudio.com viewing HN side by side

I love this thread! Here's my list of tools that I actually use(d). I guess I have quite some itches that need scratching :-P

Project-cmd [1] (current itch):

A cli tool to standardize working on projects in different technologies. Think of package.json but for declaring/starting/stopping containers, creating db dumps, declaring data files (archives) to back up and restore and pushing db dumps + archives to a server via ssh and pulling them. Also editing the hosts file and jumping to a project's directory with a single command.

TouchOsc Generator [2]:

If you have tried to create complex TouchOsc [3] files things get repetitive and ugly very quickly. Touchosc-generator is a templating engine for TouchOsc files. You can create and reuse components and repeat + place them in grids via simple json files.

Emailed invoices

A simple node script checking my inbox for emails containing invoices simply regexing the sender and subject and automatically uploads them to the correct month's folder on my nextcloud server. Highly useful for accounting.

Accounting

A terrible meteor spa I wrote in 2015 for creating invoices and giving a simple accounting overview for my consulting business. It's quite crappy in some respects, but I created every single invoice since 2015 with it, so who knows...

D39r

My last flat had 2 levels and opening the door for the mailman meant running as fast as I could to the other end of other level of the flat. After opening up the intercom and finding that pushing the door button simply closed a circuit between 2 cables which in turn opened the door of the apartment building. An arduino relais, raspberry pi and a little bit of hacking later I could open the door via my smartphone. I used this as long as I lived there.

Mushrooms

I digitized a book about mushrooms with ~1200 pages by taking the book apart, scanning all the pages, writing a script to restore the pages order, using opencv to automatically detect blocks of text and images in the scans and mapping each image to the corresponding text blocks. Then used tesseract for ocr, manually corrected ~3000 paragraphs of texts with my girlfriend and developed several scripts to extract mushroom features for easily indexing/finding with a web app. Wouldn't/couldn't publish due to obvious copyright issues. This was a lot of work and I loved it!

[1] https://github.com/martinwittmann/project-cmd

[2] https://github.com/martinwittmann/touchosc-generator

[3] https://hexler.net/touchosc

I wrote a tool that forwards selective Android notifications to a Telegram bot: https://github.com/fishy/notifbot

I wrote two blog posts to explain the background context and the motivation: [1] & [2]. The tl;dr is that I have some home automations around the garage door that is not 100% reliable, so I'd like some notification on Android Auto that could give me some confirmation. The app sending those notifications doesn't support Android Auto, but Telegram's android app supports that pretty good.

While that's the original motivation, after years of using it I also found other good uses of it: to convert notifications from some super annoying apps into something less annoying.

[1]: https://wang.yuxuan.org/blog/item/2017/03/smartthings-myq-an... [2]: https://wang.yuxuan.org/blog/item/2017/05/notifbot-android-a...

Scraper to check for covid 19 vaccination appointments for my dad. Never had to use it as his health care provider proactively got him signed up.

Scraper to check Target for PS5 stock every 90 seconds. Never returned any hits in a week, which I believe reflected reality, then I found one at Best Buy.

Daemon to repeatedly check internet speed and spit out a CSV, which I then graphed. Point was to see if I was getting sub par speed and ask for a credit; turns out the speeds were fine.

Just for fun daemon that spammed my friends' WordPress blog message form. Involved using OCR to break the (very weak) captcha, which was fun. Sent over 100k snippets of various garbage fan fics. I don't think they ever checked wherever the messages go.

Scraper which looked for chair massage appointment openings and emailed me when it found them. We used to get massages at work, but the slots went quick. Worked great.

TODO: I found out some of my photos in Google Photos are of interior quality. I want to write something to compare my local copies to their cloud counterparts and indicate which are sub par. I'll then upload the higher quality versions somehow.

TODO: scraper to enter all my financial account balances in a spreadsheet daily. I currently do this manually twice a month.

A bunch of shell scripts I've written over the years are available from https://git.marcofontani.it/mfontani/scripts

Very useful ones:

- h, to take the first line of output and output it as is, then running the command that got passed. Example: ps faxuww | h grep foo to show the "ps" first line (the header) then running "grep" on the rest

- evenodd, to colorize the background of lines of text so it's easier to see which start of text corresponds to which end of text

- time-rollup, to time the time it takes to run a given command and provide percentage-based statistics on the execution

- a wrapper around "jq" to make it DWIM w/regards to gzipped, bzipped, and zstd-compressed files

I've also put some full-fledged binaries on github:

- https://github.com/mfontani/prettycrontab which is a crontab pretty-printer which parses a possibly specially commented crontab to give you an overview of what's coming up next

- https://github.com/mfontani/tstdin to timestamp your stdin, and provide when the line was received, how long it was since the start of the command, and how long it was since the last line was received. Useful to add at the end of a pipe to both log and perform analysis on the output and time it took to do stuff

- https://github.com/mfontani/rofixec to "sorta template" a rofi (a X11 runner) runner so it picks commands from a given list (provided as yaml or json configuration) and executes the picked item in a background job

- https://github.com/mfontani/git-recent which helps you pick the most recent branches you've worked on, very useful when paired with fzf for picking

- https://github.com/mfontani/los-opinionated-git-tools instead contains a ton of useful little git-related scripts, from one which DWIMs the master/main/blead branch name to one which helps you reauthor the last commit, to one (git-rr) which helps you perform a git rebase with context info about the commits you're rebasing: which files they touched, etc - to make it easier to fixup together commits which touched the same file... which is an operation I do so often I've created a "git-fixup" script, which automates fixing up the currently committed file to the last commit which touched that file in the branch

drive.py

Disc comare tool

https://github.com/web3cryptowallet/drive-py

I made it to work with unstructured data with any amount of size

emailmynotes.com (the backend is down right now, working on moving to cheaper hosting)

Send yourself notes from an untrusted computer, without entering passwords.

i built yen.chat so that i didn't have to pay for slack... i use it for internal communication with my team as we build a b2b saas tool.

i hate slack.

the nyt newswire page auto-reloads.

not my version:

https://nytnotifier.com/

A PCD to E57 file converter for 3D pointclouds

During last lockdown in March, it became really hard to get grocery delivery slots online. And everything offline was, well, mostly shut.

The delivery slots would run out within 15 minutes of being open. So I hacked together a script that'd poll for delivery slots and notify me on whatsapp whenever there were slots.

This year I had to do the same for vaccine slots. In fact, getting a vaccine slot became a bit of a hackathon in India due to limited slots with multiple GitHub repos and hosted tools coming up to notify you of available slots.

Not really a computer program, but a list of all the best sites to visit that all spawn from a single folder in Firefox. It's opinionated, and one of the links is of course Hackernews, but also other sites like lobste.rs and old.reddit.com/r/programming etc Firefox lets you spawn a bunch of tabs and it saves me from having to manually click each link's URL. I use it very heavily. I am very thankful for the `Open all in tabs` feature.

shareseer.com to find public company filings efficiently

Code generator based on CUE

https://github.com/hofstadter-io/hof

I always bookmark these idea mining threads, has anyone ever made use of them?

My though, because I haven't, is that if you want to essentially work on someone else's idea then go be an employee, otherwise the first actually passionate person will steal the show as soon as they show up.