Sometimes that's not good enough tho. What are some tools, libraries or services you built, are they open-source and why weren't you satisfied using what already existed?
I built it because I was making screencasts and cutting out silence + mistakes was 90% of my editing time. This makes it a ton faster. There were some command-line scripts to do a similar thing but I wanted something visual with a fast feedback loop, where I could quickly preview how it would sound and tweak the parameters in real time.
I didn’t know anything about video and had never built anything with Swift before so it’s been a fun way to learn a bunch of new stuff.
I built it to make torrent technology more accessible to the masses. We’re still actively building it and we even have a slick desktop app that uses the same engine for streaming.
WebTorrent also powers https://wormhole.app an end-to-end encrypted file sending service that I built with my friend jhiesey.
[1] https://www.listennotes.com
[edit] This is my Show HN of Listen Notes in early 2017: https://news.ycombinator.com/item?id=13310834
Last year I removed the jquery dependency and cleaned it up based on a lot of lessons that I learned, renaming it to hmtx:
Same idea: extends/complete HTML as a hypertext so you can build more advanced UI within the original hypermedia web model, with a cleaner implementation.
Part of that cleanup involved me pulling out some functionality around events and a proto-scripting language (ic-action), and I enjoy programming languages, so I created a front end scripting language to fill that need:
It's based on HyperTalk and has a lot of domain specific features for lightweight front end scripting, kind of a jQuery or AlpineJS alternative.
scrypt: Because the world didn't have any strong password-based key derivation functions.
spiped: Because using stunnel or ssh tunnelling to connect to servers is gross.
kivaloo: Because I wanted a high performance KV store optimized for small values (e.g. 40 bytes) rather than larger "items" (each containing multiple key-value pairs) or "blobs" (e.g. cached chunks of HTML).
It also has a selector for the source timezone, but that doesn't work, for reasons I've forgotten. I think that part was intended to allow me to see times without tz data included, reinterpreted as being from other tzs, but I never ended up using it enough to fix.
I made this because I often read some logs, thought "hmm when was this again?", then typed "UTC to EDT" into a new tab, and then ended up on some ad-loaded page that with dropdowns to select things like the year. I don't want dropdowns! I've already got a timestamp. I made this over a year ago and I use it 2-3x/week.
https://aeroheim.github.io/midori/
It's basically a post-processing pipeline implemented with Three.js and WebGL using a few shaders that I wrote.
I created it primarily because I needed it for one of my current projects, so the use case is fairly niche and mostly only relevant for stuff like creative coding. It was my first dive into computer graphics however, and I learned a TON about computer graphics in general and had a lot of fun writing the library.
- fae [https://h3rald.com/fae] · a minuscule find and edit utility
- h3 [https://h3.js.org] · an extremely simple javascript microframework
- hastyscribe [https://h3rald.com/hastyscribe] · a professional markdown compiler
- hastysite [https://hastysite.h3rald.com] · a high-performance static site generator
- herald [https://h3rald.com/herald-vim-color-scheme] · a well-balanced vim color scheme
- litestore [https://h3rald.com/litestore] · a minimalist nosql document store
- min [https://min-lang.org] · a small but practical concatenative programming language
- mn [https://h3rald.com/mn] · a truly minimal concatenative programming language
- nifty [https://h3rald.com/nifty] · a tiny (pseudo) package manager and script runner
- nimhttpd [https://h3rald.com/nimhttpd] · a static file web server
When I press F16, I get an image capture cursor, and the area selected is turned into text.
Example:
https://files.littlebird.com.au/Screen-Recording-2021-05-17-...
The year before that, a tool for visualizing ping latency as a heatmap [2]. My laptop's wifi had developed a severe latency stutter every ~500ms that was driving me nuts when using SSH and other interactive tools, not to mention killing my throughput. Once I could visualize it and saw the pattern, it was very clear that there was a system-level issue. Eventually traced it to a virtualization product's network driver.
It's definitely a pattern for me -- feel frustrated with diagnostic and data viz tools that are either too slow to handle or too complex to configure when I need them, and try to build simple tools that solve exactly the problems I keep bumping into. These smaller projects also provide good opportunities to practice with new languages or frameworks.
[1] https://github.com/acj/krapslog-rs (also krapslog-go)
- Zola (https://github.com/getzola/zola) a SSG that works like I wanted and had a template engine close to Jinja2. I was using Hugo at the time but can't stand Golang template engine (imagine my sadness recently when I realised what Helm Charts are using...)
- Tera (https://github.com/keats/tera): a template engine pretty close to Jinja2/Django templates - at the time it was made only Handlebars existed in Rust and it was not enough for what I needed in Zola
- kickstart (https://github.com/Keats/kickstart): an equivalent of cookiecutter from Python but trying to be more interactive/powerful as a simple binary, see the GIF in the repo for an example
- validator (https://github.com/Keats/validator): my take on Python marshmallow validations, nothing existed at the time.
So yeah, most of my open-source is re-creating libraries I use with Python in Rust.
It reports the time spent on each line of your project, and you can filter which files are included. For example, you might do a complicated map operation which calls a function in another library, if you filter out the library then it will report that all the time was spent in your code on the line that performed the map. However, if you don't filter out the library then it will report that all the time was spent on the lines inside the library.
I was tired of looking at profiling reports filled with lines of code I had never seen before.
I couldn't figure out how to get what I wanted from the existing profiling libraries so wrote this. It was quite easy once I figured it out. Julia has a built in sampling profiler you can turn on, and from there you can process the sampled stackframes however you'd like and display them however you'd like.
It indexes the site and generates search functionality in JavaScript (the index is just a static JSON file) that can be uploaded wherever JS/HTML/etc. files can be uploaded. I thought it might be useful for people with sites on GitHub pages or similar who don't want to use one of the major search engine company widgets.
Also my back of the envelope calculations were that the simple search index for a small–medium site won't be that big.
I found most database migration tools tried to be too smart (I'm not a fan of automatic migrations), were too tightly integrated with specific languages or frameworks, or didn't support basic developer workflow pleasantries such as dropping and recreating the database.
I created a simple single binary migration tool that runs migrations (sql files), and keeps track of applied migrations in a table (inspired by Active Record migrations). Dbmate works with any language or framework, and generally tries to be useful while staying out of your way.
Comparison against other tools here: https://github.com/amacneil/dbmate#alternatives
• https://instadj.com - simple app for making youtube playlists, wanted a simple app for playing music at parties (example: https://instadj.com/wam)
Both are open source.
https://nlh.me/projects/celestite
Still very much a WIP, but it works. You can build your front-end in pure Svelte components and it supports server-side rendering, client-side hydration, and all that good stuff.
I did this entirely to scratch my own itch - I love working in Crystal (it's a beautiful, elegant language) and I love working in Svelte (modular, reactive web components) and it all just fits together nicely.
Would love feedback / contributions!
I've made
- A dynamic programming language, Ink (https://dotink.co), which runs in "production" (for whatever that means for side projects) for around a dozen projects written in it.
- A compiler to compile that to JavaScript (https://github.com/thesephist/september)
- A bunch of language tooling around that language, like syntax highlighters, editor plugins, code formatters (for example, the code formatter https://github.com/thesephist/inkfmt)
- A small UI library (https://github.com/thesephist/torus)
- A suite of productivity tools (https://thesephist.com/posts/tools/) like notes, todos, shared whiteboard, contacts/CRM
- Twitter client (https://github.com/thesephist/lucerne/)
- Theres a few dozen more at (https://thesephist.com/projects/) :)
Many of these end up building on top of each other, so across the few dozen projects built on top of these tools they form a nice dependency graph -> https://twitter.com/thesephist/status/1367675987354251265
I'm a huge fan of Git, and the Git mental model just makes sense to me. I wanted to manage my dotfiles in the same way. At the time I had tried several other solutions, mostly similar tools like homeschick and vcsh.
I wanted a solution that was very portable, which both of those existing tools were. However, homeschick became a bit clunky to use because each time I wanted to do most operations I had to first "cd" into my "castle". In addition, that tool used symlinks, which doesn't work out well to manage a file that may get overwritten by a tool.
vcsh was the other main tool I tried. This tool adopts the bare repo technique, allowing files to be used instead of symlinks. The major drawback it had was that it was designed to work with multiple repos, and forces you to specify the repo with every command. Some simple aliasing helped mitigate that though. But by that time I also started writing some custom code to encrypt private data and was struggling to maintain different branches for different systems which had slight tweaks to configurations. It just became all fragmented and difficult to manage.
That is what lead me to create my own tool. The important features I wanted: portability, seamless interaction with Git, alternate files for different hosts, encryption for private data. I shared it as open source back in 2015 and it has grown in popularity some. It's been improved a lot over time including contributions from others. I'm glad so many others have found it useful.
One of them lets a developer mark a C# method such that the method must be invoked with named args [1], calling it with positional args is a compile time error then.
And the other makes it a compile time error to discard a marked method's return value [2]. Kind of like it is in functional languages.
Was learning/practicing F# along the way, so the code is probably not so good. But it works :)
It is useful for parsing and emitting binary structures. It uses Go struct tags to allow you to define fairly advanced arbitrary structures. Unlike some similar libraries, it supports both reading and writing data. I used it to write a quick program that manipulates FL Studio project files, and another that extracts PNGs out of a blob (like binwalk but more accurate for this specific task.)
https://github.com/jchv/pngextract
https://github.com/jchv/flsplit
If you’ve never seen Kaitai, it might take a while for it to click what you can do with it. I was actually inspired by 010 Editor’s binary templates, but found out about Kaitai Struct after creating Restruct. I stole their idea of having arbitrary expressions and wrote my own expression engine for Restruct, and also ended up contributing improvements to Kaitai’s Go compiler too, for good measure. The bottom line is, these tools make it extremely easy to work with complex binary files. I can incrementally sketch out an unknown file format, like FL Studio FLP, and quickly test my assumptions about structure shape. Kaitai also has their IDE tool, which lets you use Kaitai interactively:
I actually hope to do the same for Restruct, but want to re-engineer some aspects of it to make it work better in an interactive context.
However, I noticed that existing open-source implementations of AlphaZero mostly consisted in complex C++ codebases that are highly specialized for specific games (eg. Leela Zero and LC0). Accessible Python implementations could be found but they were usually too slow to do anything useful on limited computing power.
Seeing this, I built AlphaZero.jl: https://github.com/jonathan-laurent/AlphaZero.jl
AlphaZero.jl is written in Julia and it is consistently one to two orders of magnitude faster than competing Python alternatives, while being equally simple and flexible. I just released a new version a few days ago with many new features (support for distributed computing, support for arbitrary MDPs...).
If you are a student, a researcher or a hacker curious about AlphaZero, please consider having a look!
- https://volt.fm - See, share and compare your Spotify stats
- https://postsheet.com - Send emails to contacts in a Google Sheets or Airtable document
- https://pikaso.me - Screenshots Twitter for sharing on Instagram
- https://github.com/soheilpro/zsh-vi-search - Adds support for searching the current line (in normal vi mode) to zsh
- https://github.com/soheilpro/catj - A better way to display JSON files
- https://github.com/soheilpro/mann - Never forget command line options again
- https://github.com/soheilpro/pgcmd - Non-interactive PostgreSQL query tool
- https://github.com/soheilpro/sqlmon - Collect events from SQL Server and save them to Elasticsearch
- https://github.com/soheilpro/sqltop - Find the most resource consuming SQL Server queries
- https://github.com/soheilpro/mon - Painless performance monitoring for Windows
- https://github.com/soheilpro/Ledger - Interactive CLI double-entry accounting
* The existing backup tools, that are all hyper-specialized, all configured differently, all have slightly different feature sets, and so on. You will likely have very different tools to backup, say, your /etc folder and your mariadb database
* cron is cool, but its logging/alerts capabilities are… subpar, to say the least
So I’ve developed tools to alleviate my pain in those two areas.
I’ve just open-sourced the first one : https://github.com/sloonz/uback/. Feedback is welcome ! I’ll probably make a Show HN post about it when it hit 0.5.
For the second one, I’ve made some tools to monitor cron jobs. Not released yet, but open-sourcing it is on my TODO-list too. It will need way more polishing for it tho.
On another shameless plug (but it’s the topic of this post, so let’s be shameless indeed), I needed something very similar to vouch-proxy but that could protect multiple unrelated domains and be configurable with a database (because I’m not the one who is going to configure the ACL, and the guy who is going to configure the ACL is perfectly able to use phpmyadimn). Since the guys behind vouch-proxy were not willing to accept the changes necessary to make this work, I decided to create my own alternative : https://github.com/sloonz/ngx-auth
I'm using it to automatically collect papers published by members of the research institute I work for, it's working pretty well.
I also made a small utility to sync folders on-demand on my different machines: https://github.com/breuleux/synecure
Most of the work is done by a library called bsync that someone else had written, which itself uses rsync, but I'm quite happy about the interface I made. By default it syncs home-to-home, so you don't have to specify both the source and destination directories. You can just type "sy -r remote" in ~/whatever to sync it to ~/whatever on the remote.
Makes any macOS .dylib or executable portable.
It (recursively) makes local copies of all the dynamic libraries on which you depend, and rewrites all load commands to prefer the local copy.
This lets you safely distribute your software to another computer (rather than discovering it only works on your computer because of your brew installs).
https://gist.github.com/Birch-san/e84cfa3b93ffa104af2bd9a047...
Explanation, diagrams: https://birchlabs.co.uk/blog/alex/juicysfplugin/synth/cpp/20...
Also forked a scripting language https://github.com/mingodad/squilu and extended it to accept a pseudo C++/Java/CSharp/Typescript syntax to make easy to reuse code and have fast iteration when creating new functions (with it and minor changes I could get https://ssw.jku.at/Research/Projects/Coco/ parser to work for easy grammar development).
Create a tool for create, document and prototype database applications at "user level" in near realtime (live) https://github.com/mingodad/db-api-server.
Extended GLPK to accept a bigger subset of AMPL and made some performance improvements in the GMPL interpreter https://github.com/mingodad/GLPK
- Mockit - A tool to quickly create mocked APIs.
- awsicons.dev - Quickly find AWS icons
- EventBridge Atlas - Discover and document your AWS EventBridge schemas
I'm currently building a tool that will hopefully help all open source engineers in the world.
I want to give open source engineers the ability to quickly create landing pages for their GitHub projects.
I think README.md files can only go so far, but (for me anyway) nothing beats a nice landing page selling your open source project.
Not all of us have the time or skills needed to create landing pages so I built https://gitpages.app that can help everyone.
https://gitpages.app is a tool that hopefully can inspire and help open source engineers. It's still in development but if people are interested let me know.
Cheers!
Over the past 5 years we’ve been building custom B2B and back office web applications. Nothing in the market had the level of customization we required both from a technical and commercial angle. So decided to standardize how we “configure” apps into a platform.
We did this by designing a schema by which to define web apps which is easy to read, write and understand, and works well with normal developer tools like editors, git and CI. While keeping it self hosted and even server-less.
Lowdefy has enabled us to rapidly deploy custom business apps like BI, CRM to MRPs.
Check it out :) https://github.com/lowdefy/lowdefy
Building notations on top of it, currently focusing on one for data -- an alternative to XML, JSON et al.
Open-source, prototyping on GitHub[1].
Keepin' it simple ain't easy.
TODO list and personal project tracker - like TaskWarrior but SQL-accessible https://github.com/andrey-utkin/taskdb/wiki
sqlhub.net - Access to public datasets in form via PostgreSQL server https://github.com/sqlhub-net/sqlhub-net/wiki
- [0] https://golang.cafe
- [1] https://github.com/golang-cafe/golang.cafe
- [2] https://golang.cafe/Golang-Developers
> Checkbot is a Chrome extension that tests 100s of pages at a time to find critical SEO, speed and security problems before your users do. Test unlimited sites as often as you want including local development sites to find and eliminate broken links, duplicate content, invalid HTML/CSS/JavaScript, insecure pages, redirect chains and 50+ other common website problems.
I build this to automate audits I kept having to do manually while doing frontend work. I also liked the idea of it helping to teach people about web best practices, so tried to make it easy to use with minimal jargon explanations (see https://www.checkbot.io/guide/).
It written with Vue + TypeScript + Firebase + Paddle.
There's a free tier with no sign-up required - give it a quick try on one of your own pages and it'll usually find something to fix you didn't know about.
The two biggest things Ive built for with this tech is a multithreaded scripting engine using Qt, Lisp and acoreconsole, and a search engine for Autocad files that searches our entire CAD library for strings, etc.
Between these two applications, Ive saved my last company thousands and thousands of man hours.
I left because they didn't care.
I realized a few years ago that SQLite was the perfect tool for doing data analysis at the small-data scale, where small data is less that 10GB which is pretty much everything you might want to analyze - especially for personal projects.
So I've been building tools to fill that niche!
I've looked into previous tools but their services were all too expensive. They also didn't have the granularity I wanted in the options you could choose for campsites. We tried expanding to the USA last year but since we made it a paid service, it's been hard to advertise and get into the market. When we were free for the first month, we got multiple local radio interviews and news stories which really helped bring that critical mass of users in.
I made webUSB postage scales and a webUSB thermal printer.
We used to use Dymo label printers etc, but macOS' printer queue would get stuffed up every 200 or so prints.
The advantage of a webUSB based solution was:
- No OS based printer queue to get gummed up
- Super-fast (just ZPL printer commands being sent down the wire)
- One-click to create a postage label
- Automatic label printing when a new order comes in (Websocket + WebUSB)
- Live parcel weights and prices updated via Javascript
[1] Demo: https://vimeo.com/334547755/c387957a25
It was not originally open sourced; it was a commercial product for some time.
I wasn't satisfied with what already existed at the time (and neither were our customers) because most regular expression libraries are not focused on performance (using backtracking), streaming (again, backtracking) across multiple inputs - e.g. packets - without holding on to old data - and handling lots of regular expressions at scale.
re2 came along while we were still doing a commercial project but had zero impact on our sales, as it didn't handle streaming (weirdly, imo, as it could have) but it also didn't scale very well to large numbers of patterns.
I also designed simdjson (https://github.com/simdjson/simdjson), although others (chiefly Daniel Lemire and John Keiser) now do all the real work. It's still my design under the hood (although the "On Demand" stuff is significantly new and different). I built the first prototypes of simdjson because Daniel trolled me with a paper from Microsoft and I was bored.
A tool to find identical files.
Compared to other tools that do similar things, it can also find identical directories, handles archives and is designed to work with millions of files efficiently.
It works is two steps: first make a list of files and checksums with xmd5 and analyze it with dupfiletree.
Made for personal use, not documented, designed for performance first, stable enough for me but use at your own risk.
* Secure: As a tightly specified format, Concise Encoding doesn't suffer from the security problems that the more loosely defined formats do. Everything is done one way only, leaving less of an attack surface.
* Efficient: As a twin binary/text format, Concise Encoding retains the text-based ease-of-use of the old text formats, but is stored and transmitted in the simpler and smaller binary form, making it more secure, easier on the energy bill, and easier on the planet.
* Versatile: Supports all common types natively. 90% of users won't need any form of customization.
* Future-proof: As a versioned format, Concise Encoding can respond to a changing world without degenerating into deprecations and awkward encodings or painting itself into a corner.
* Plug and play: No extra compilation steps or special description formats or crazy boilerplate.
Reference implementation (golang): https://github.com/kstenerud/go-concise-encoding
Enctool, converter for playing around with the format: https://github.com/kstenerud/enctool
Along the way I worked on a Go implemenation of DTLS that gets used on its own a bit https://github.com/pion/dtls
In another life I wrote Therac https://github.com/sean-der/therac. A PHP debugger that was viewable from a browser. I was a remote at the time (2015) and it was a great tool to use with others.
I also wrote fail2web https://github.com/sean-der/fail2web a web frontend to fail2ban
https://addons.mozilla.org/en-US/firefox/addon/container-tab...
It's not open source because, frankly, it's still hard to run a business on open source -- especially without VC backing (Reviewable is bootstrapped). After all these years things are still growing nicely and while I've run the show solo for a long time I started hiring full time folks in the last year or so. (If you think you might be interested to join, ping me and let me know!)
Edit: I love these threads. You read so many things and Frameworks and random stuff that you really learn in what silo you are actually living
I just wanted something that works as promised and respects the user (open source, 70kb total payload size, no ads, no tracking, feature complete, etc)
When I was a teenager I made a bunch of games for which I created level editors and the like. This was before there were free alternatives that I knew of which fit my needs.
When I started with graphics programming I made a library with OpenGL helpers for setting up shader programs, textures, double buffered textures, etc. configurable via configuration files. I ended up using it for a number of private projects and my master's thesis.
I've also made a Vim plugin for handling projects: setting up working directory, loading session files, setting a number of project specific paths and compiler options, etc. I wanted it to do enough little things that it was difficult to find a ready solution.
I once had a number of video files with subtitles which were out of sync, so I made a command line tool to resync them. It only took me a few minutes so it felt worth it and was very satisfying.
The problem I found with most existing providers is they require you to create an account and often subscribe before you can use their services. For a quick test that's excessive overhead.
Until recently I was using prism[1] to run the mock server locally, but it's very limited when it comes to configuration and you have to install and run it locally, which again it's an unnecessary overhead when you want to run a simple test.
I've been using microapis.io for a few months now with my clients and it's proving a life saver to run integration tests and to help the frontend and the backend teams to work separately while ensuring they both comply with the same API specification.
There are many I have tried before this project, but there is something always missing. I primarily work on React and so my experience can be a little different from people working on other view libraries.
Following are few libraries I tried and my pet peeves with them. Material UI was just too complex in terms of use. I had to always have a doc open in a tab and refer it for even a simple component like toolbar. Antd bundle size is way too large and few essential components like timepicker is > 100KB gzipped. React bootstrap doesn't have theming and looks outdated (Bootstrap 5 will fix this).
[1]: https://github.com/DarwinAwardWinner/ido-completing-read-plu...
[2]: https://github.com/DarwinAwardWinner/with-simulated-input
It was partly just a way to try out Svelte and XState.
It was an experiment in Rust, and I even made a little GUI too!
It's a suite of tools to work with DNA sequences (from simple tasks such as reverse complement to medium complex tasks such as multiple sequence alignments and primer design).
I built it because I wasn't very happy with the existing tools. It never got very popular, but after all these years I still think it's a very useful tool.
Made it simple enough such that it requires no account, no payment and no app. Developed using React, Typescript, Firebase. Credit to all the libraries that I could leverage to build this.
Feedback on esyvite.com welcome at vamsi dot narla at gmail dot com
I was so fed up trying to debug lambdas and the other AWS offerings that a tool like this to see program output in near realtime is indispensable. I use it all the time.
Is it bug free? No
Did i write tests for it? Also no.
Is it useful? Yes.
[0]: https://chronver.org
https://gitlab.com/stavros/harbormaster
It allows you to run Docker Compose containers from a simple git repo (no Docker registry), and to specify all the Compose apps you want to run in a straightforward YAML file. It'll take care of automatically pulling/restarting/deleting everything for you.
I love it.
- qssb.h: A header library to make sandboxing applications on Linux more easier. Currently at an early stage though: https://github.com/quitesimpleorg/qssb.h The original aim was to make utilizing namespaces and seccomp easier without dealing with nuances. Currently working to get landlock in, then perhaps a CLI utility and test cases.
- raou: I found sudo too complex for the simple taks of switching users on a system. Given sudo also had some vulnerabilities in the past, I decided to write an alternative in Rust: https://gitea.quitesimple.org/crtxcr/raou
- qsni: https://github.com/quitesimpleorg/qsni At times I simply wanted to cut off a few applications from the network or to assign some specific firewall rules: https://github.com/quitesimpleorg/qsni
* a Java library to open up ports on your router, because at the time nothing existed for Java that handled all 3 major port mapping protocols.
* a Java library implementation of Kademlia, because I wanted to learn the protocol.
* a Java coroutines toolkit, because I needed the functionality but at the time Javaflow was dead but Project Loom wasn't yet a thing.
* a Node library that extends markdown-it with my own special flavour of Markdown that I use for taking long-form notes. It automatically links terms in the document and lets me call into container images to generate outputs (e.g. generate chemfig/tikz/svgbob/graphviz diagrams, run a block of python and spit the output, etc..). I built this one because, at the time, Google Docs just wasn't cutting it in terms of features and had some bugs when the doc was hitting the low hundreds of pages. A sample of the MD <https://raw.githubusercontent.com/offbynull/learn/master/Bio...> and its rendered output at <https://offbynull.com/data/learn/Bioinformatics/output/outpu...>.
DIY everything is my path to programming happiness (in any field in fact). Tools should be extensions of your body, tools made by others are unlikely to be that.
- https://github.com/rcarmo/pngcanvas because there was nothing similar that ran on Google App Engine
- https://github.com/rcarmo/imapbackup because I needed a migration tool from Sun IMS to Exchange
- https://github.com/rcarmo/rss2imap because it helped me survive well beyond Google Reader for a long time
- https://github.com/piku/piku because it enabled me to automate away 99% of my non-Docker deployments and is a lot more fun than Kubernetes on low-end standalone boxes
There’s also my blog engine (https://github.com/rcarmo/sushy), but that is in a state of flux right now and I haven’t published the new source yet.
First one is ProxyAV [1] - reverse proxy that scans any uploaded file with ClamAV. That tool/microservice was created, because backend developers didn't have experience to work with antivirus on their side, so the "mitm proxy" way allows to integrate antivirus scanning without bothering backend devs, they always receive clean files
The second one is etke.cc [2] service. I love matrix, but self hosting of matrix homeserver requires good level of expertise, even for skilled sysadmins. I just wanted more people join matrix with their own homeservers, so etke.cc service is perfect solution to that problem - you want your own matrix homeserver - you order it on etke.cc - you get your matrix homeserver, on your domain, on your server, with full control of it.
[1] https://gitlab.com/rakshazi/proxyav
[2] https://etke.cc
When I saw how slow it is to fork child processes in Windows, I then realized I wanted to run ExifTool in "stay-open" mode, which meant I needed to manage 1 or more long-lived child processes that communicate via stdin/stdout, so I wrote https://github.com/photostructure/batch-cluster.js
In switching to TypeScript, I really missed Scala's `Option/None/Some` and `lazy`, so I added those (and several other small, helpful functions/classes) that I documented here: https://photostructure.com/coding/uncertain-lazy-forgetful-a...
I often have to perform statistical tests on genomic data. Which in practice means running the same test on every gene (row of a matrix). Running it separately on each row is slow, specially in R. Hence to speed it up I started an R package which is a lot faster and deals nicely with edge case scenarios (missing values, infinities, empty matrices, etc).
- R package "annmatrix": https://github.com/karoliskoncevicius/annmatrix
An S3 object for matrices with persistent metadata. This again is mostly relevant in genomic contexts where a matrix of, say, gene expression has to also keep information about rows (gene names, positions, chromosomes), as well as samples (disease status, age, sex).
- R package "basetheme": https://github.com/karoliskoncevicius/basetheme
On of the advantages of ggplot2 in R is the ability to specify themes. I prefer working in base plotting system and ended up creating a package that allows setting themes for base graphics.
- Vim plugin "sendtowindow" https://github.com/karoliskoncevicius/vim-sendtowindow
A minimal plugin which implements an operator for sending text to another window. Handy for sending code from the buffer to a REPL running within another ":terminal" buffer.
I also developed a Lua debugger [2] and serializer [3], as well as took on maintenance of wxlua project for the last 5 years [4]; all open source.
[1] https://studio.zerobrane.com [2] https://github.com/pkulchenko/MobDebug [3] https://github.com/pkulchenko/serpent [4] https://github.com/pkulchenko/wxlua
A tiny tool I wrote to search within file piles (mostly unsorted downloads, torrents, and such). I could never remember `find` options, and more advanced queries are a pain. Now one can use some kind of SQL flavor to get the job done.
I literally started coding Quepid next to a colleague complaining about search so I could help them. It’s basically a kind of test driven approach to continually tuning and proving you’re not harming existing use cases too much. The first version that day was super hacky :) but it worked: it was a “single page server side application” ;). Just dumping a huge HTML page from flask about how our search was doing based on stakeholder feedback.
Nothing out there existed that did what I needed. Tooling around search engines for relevance just wasn’t great. In part because it wasn’t paid as much attention to ~10 years ago when I worked on creating these tools.
On top of this I have made many projects and I still use all of them today even 10 years later, some favourite:
http://fuse.rupy.se (multiplayer system)
http://tentacle.rupy.se (digg)
http://sprout.rupy.se (wordpress)
http://talk.binarytask.com (reddit)
I also made my own cloud service both with my own hardware and on top of GCP:
http://host.rupy.se (raspberry 2 cluster)
- My own key-value store that versions values by default. partly for fun, partly for things like caching: https://github.com/queer/crush
- A Spring-inspired web app 'framework' for fun and learning: https://github.com/queer/autumn
- Slowly building my own k8s-inspired container scheduler; frustration with k8s led to me building this: https://github.com/queer/mahou
Here's the Hacker News rss feed in action! https://rss.mchone.dev/?feed=https://news.ycombinator.com/rs...
Here's the engadget rss feed as well. It's more content-rich https://rss.mchone.dev/?feed=https://engadget.com/rss.xml
And here's my github repo: https://github.com/BenMcH/remix-rss
The story goes like this....
I was writing a book called "Hands-on Blockchain for Python Developers" in 2018. At that time, the only Pythonic blockchain development framework which supported web3.py and Vyper (a smart contract language that has syntax similar to Python) was Populus. A week after my book was published, Populus was killed by its developer.
So I decided to create one to support Vyper language.
However, I need to tell you that there is another blockchain framework that supports Vyper and web3.py which is more popular than my framework. It's Brownie-eth. If this tool existed in the first place, I wouldn't create Mamba. But hey, such is life. Now I have to raise my child, Mamba. ;)
It's a general purpose web scraping library for Python that replaces BeautifulSoup + requests for most projects.
Just surpassed ~2K downloads every week!
https://github.com/ludocode/pottery
These templates are composable: high-level templates are implemented using lower-level ones. It also supports custom lifecycle functions, so you can tell containers how to copy, move, destroy your values; it supports custom array access functions, so you can use algorithms like sort or heap over a generalized array that may not be contiguous in memory; and more.
There is still nothing else like it as far as I know. The closest alternative is CTL but it doesn't have any of those features:
- I use more than one browser and wanted changes to reflect across browsers - While on my daughter's computer, I wanted to permanently block a few websites, however, for my own computer, I wanted an easy way to activate and deactivate deep-work mode.
Technically, I don't do anything smart and utilitze /etc/hosts file, but this tool has really helped me overcome my Twitter addiction.
[0] https://github.com/abhinavs/blockr ; brief write-up on my blog - https://www.abhinav.co/blockr
[1]: https://smocker.dev
A button to create new files inside macOS Finder (`touch` without the terminal).
https://github.com/ivanmaeder/finder-touch/
(⌘ + Shift + N creates new folders by the way.)
This I just published now, I use it multiple times a day: an iOS shortcut for emailing myself things.
https://redchamp.net/blog/email-me
A command-line script for bulk-renaming files (it lets you edit file/dir names inside a text editor).
Repo: https://github.com/dmotz/trystero
Demo: https://oxism.com/trystero/
The goal is to allow adding P2P/multiplayer to your web app in a few lines and no server setup.
While there are a few good abstraction libraries out there (this one builds on simple-peer), I felt the need the set up a server for matchmaking peers was too much friction for experiments and too centralized in the context of P2P apps. Trystero abstracts away the matchmaking aspect using BitTorrent, IPFS, or Firebase behind the scenes.
- https://hackage.haskell.org/package/panpipe
- https://hackage.haskell.org/package/panhandle
They're described in more detail at http://chriswarbo.net/projects/activecode
Just extracted the Monte Carlo Search Tree logic into a package called Carlo [1]!
It's used for pretty much every calendar in the Airbnb app besides some legacy ones that we haven't ported over yet, so check it out if you're building something that needs a date picker component that's super customizable!
(NB: once the project was determined to be useful we moved it to the Appium org and it has seen lots of contributions from others, not just me)
Ideogram supports genomic views to research and report findings on cancer, clinical variants, gene expression, evolution, agriculture, and more [2]. What previously existed for genome visualization was either focused on short genomic regions (e.g. genes) or complex to set up and maintain.
I ended up making https://github.com/cjjeakle/rebalance-calc to do the same thing, but with a slicker user experience. I use it quarterly, so it definitely fits the bill for my use case, and I occasionally show the tool to friends to help explain what rebalancing is and how to do it.
I wrote the function in 2007 and I'm still using it today. It's a handful lines of code.
I also made my blog sync with my google docs - https://hexo.press
I knew both of those would be helpful for others as well, so I made a service out of each of them and open sourced the code - https://github.com/joelewis
[1] https://github.com/warmuuh/milkman
Edit: I love these threads. You read so many things and Frameworks and random stuff that you really learn in what silo you are actually living
Used only on Redshift and Postgres, but it should work with other DBs with minimal changes.
The company I was working for had staging, transformation and reporting layers in their warehouses, but no nice way to illustrate the objects in documents. Support was manged offshore so the interactive diagrams helped with handover.
The redshift space is really lacking capable tools, which is why I decided to create this.
Also: UnicodeMathML, a more-or-less-standard-compliant UnicodeMath (a linear encoding of mathematics that leverages Unicode for brevity and plain-text readability that's built into MS Office) to MathML translator – it's the only reasonably feature-complete, web-based UnicodeMath-to-anything compiler I'm aware of: https://github.com/doersino/UnicodeMathML
And various tools around Morgan McGuire's web-based Markdown renderer Markdeep – for creating presentations (see https://github.com/doersino/markdeep-slides), undergraduate theses (see https://github.com/doersino/markdeep-thesis), and drawing diagrams (see https://github.com/doersino/markdeep-diagram-drafting-board).
In addition to that I built a few other tools, like my link shortener. It does everything I need it to do the way I want it, but nothing more.
- UMASH: https://github.com/backtrace-labs/umash Fast hash functions don't usually come with collision bounds, and crypto hashes try too hard for my needs. With umash, we get speed that's comparable to regular hash functions, and a 128 bit output such that hardware failure is more likely than collisions.
- poireau: https://github.com/backtrace-labs/poireau existing heap profilers are more intrusive (first, you have to replace the allocator), and, in long-lived servers, any long-lived allocation is cause for concern, regardless of reachability. A flamegraph compatible output is also useful for visualisation.
- CSM: https://github.com/pkhuong/csm Testing an SLO-type property that's expected to hold, e.g., 99% of the time, quickly becomes an annoying exercise in balancing test duration and false alarms. CSM implements a statistically valid dynamic stopping criterion, so the tests only run for as long as needed to be confident that the SLO holds or doesn't hold.
- Reciprocal: https://github.com/pkhuong/reciprocal existing runtime div-by-mul libraries in Rust (and most other languages) are branchy, making their runtime behaviour too hard to characterise for my tastes.
By default Rails issues a cache network request per call with the built-in view fragment cache helpers. It does allow multi-fetching in some situations but not when you have multiple cache calls in the same view.
I had the idea bumping around for years but finally mangled it into working and I'm oddly proud of how weird the solution is.
So I made my own encoding, and called it Dashycode:
https://github.com/smogon/pokemon-showdown/blob/master/lib/D...
It can deal with continuous data, categorical data, normalisation of the data, log scale and NA.
I found it really useful to work on tabular data and, since it uses numpy, it is agnostic to the deep-learning framework used.
Most of its popularity is with large companies building their own internal tools where they need diagramming visualization capabilities (layouts, save/load, undo/redo, data binding, etc). So you won't see it too often in the wild, but under the surface it's used in every industry.
I love it, and I love HTML Canvas, which I wish was more popular.
I may out myself to any potential former coworkers here, but oh well. I'm proud of it.
I got tired of passing flags to Nightwatch to filter tests and looking through results to re-run failures. So I made an interactive CLI for all of that. I stopped using this once I moved to Cypress but even with Cypress' web interface, I feel something like Night Patrol would be a lot more productive.
Firebase Rules - https://github.com/jahed/firebase-rules
I didn't like how Firebase's RTDB rules were expressions in JSON strings so I built a library to build them using a lisp-like syntax to compose and re-use rules. Firebase also has its own rules language (Bolt) but I'd rather not learn and maintain yet another tool-specific language.
Promises - https://github.com/jahed/promises
This isn't a complete solution yet, I didn't get time to refine the API. But I really prefer using Promises as result types (a.k.a. either, left/right) rather than using async/await/try/catch. It's so much more powerful to write code in a way that doesn't care if your functions are async or sync. Again, kind of like a lisp, there's also power in not being tied to a language's keywords and being able to provide a more tailored vocabulary.
I have issues with the way the pytest fixture system works (parameter names matching function names), the readibility of the output, and some other things.
It started as a little learning experiment and has turned into something I've been building into what I hope will (and already is in some aspects) be a viable contender to pytest.
* https://github.com/mkmik/multidoc_yamldiff : helps making sense of diffs between single file multi-doc yaml streams, potentially with out of order documents within a stream.
* https://github.com/mkmik/runck : curl + check if downloaded file matches a hash + run it
* https://github.com/mkmik/generated-secrets : declare the existence of a secret and have a controller generate (and rotate) it. Most k8s secrets (especially where both server and client are inside k8s) are implementation details, devops folks should never need to see the them or back them up with whatever, just generate them as needed.
* https://github.com/mkmik/knot8 : alternative approach to parameterizing k8s manifest files, without having to turn them into templates.
* https://github.com/mkmik/ocipfs : Stateless synthetic oci registry that serves single layers from IPFS
I had an idea to build an anonymous bookmark sharing website [0]. I thought it would be useful for people to share links around without having to sign up, and even choose to collaborate with others anonymously/share with readonly permission. For example, teachers could share class resources with the site, update the list as they find new readings, and students can access the link anytime to see the latest list. It was a single-focused web app. As far as I know, I'm the only user, but I still keep my bookmarks there to share links between my devices.
I built my own SQL query builder in C# [1] because I disliked ORMs. It didn't sound right to me to create another overhead using a dedicated class in my code. I liked plain SQLs, but as the number of operations increased, my code quickly became messy.
I spent a week or so during holidays developing the core functions of the library and opensourced it. Not many people used it because I guess my target audience was people who use plain SQLs in their code. These people probably prefer minimal tooling, so they avoid third-party libraries. Although I stopped maintaining it after switching to Python for work, I still think it's more organized than having plain SQLs lying around in the code.
The use case is for companies to securely offer experiences as integrations to other websites, such as a live chat, comments sections, payment modal, etc.
It turns iframes into something that resembles React components (though you can use any framework inside them).
It's tiny (~7kb), fast, and has no external runtime dependencies.
I'm very proud of it but I haven't open sourced it yet. A little scared to.
You can install it using "pip install til-cli", feedback/suggestions most welcome. :)
Was inspired by Simon Willison's TIL Page
One Year of TILs: https://news.ycombinator.com/item?id=27017604
I also built a17t [1], an atomic web design toolkit that makes using Tailwind CSS a bit easier from the start.
There were others but as the issue passed or no longer needed to be dealt with they fall into disuse. Some however have ended up as part of the tools we use at work
Some even got documented :)
> Other validation tools are either focused on:
> - binding to user input forms,
> - recreating or supplementing ActiveRecord validations, or
> - supplying user-friendly error messages instead of programmatic error codes
>
> This is a design gap I'm interested in filling, as it fits my mental model for many validation cases, and is especially suitable for APIs in a way other Ruby validation libraries are not.
>
>The aim, then, is for Validryad to be a validation library that supplies programmatically useful validation errors, while performing some minimal coercion and alteration of the data as useful.
>
> The library draws on the existing dry-validation library for design inspiration, while making some concretely different decisions:
>
> - Error messages are programmatic, not user-based
> - Validation is not tailored towards hashes alone, but suited for any combination of values, including hashes and arrays
It's extremely basic, but I'm using it for current work and it does the job I need it to do. It was a simple enough tool that I figured it might be useful to push as its own library. Looking at recent discussion, it probably better fits the 'parse, don't validate' mentality, under which case it's something of a misnomer.
I started it because I wanted a note-taking app for networked thought / Zettelkasten that is easy to use for the average user (not the average Hacker News reader). So you don't need to use Markdown if you don't want to, you can format text in other ways like using the formatting toolbar or through keyboard shortcuts. And syncing between different devices is handled automatically for you since it's a web app.
I also wanted to make it open source [2] so that anyone could look at the code and contribute to it if they wanted to. I'm not a big fan of the way that a lot of the apps in this space are closed source -- you don't really know what they're doing with your data, and it doesn't inspire confidence in the app's longevity.
It's still early in development, but I'm hoping to build a solid community behind it.
https://hugodaniel.com/projects/shader-canvas/
The idea was to bring a more declarative vibe to the low-level WebGL API.
Done for a personal project, but I ended up using Three.js because my time to develop it further was running out :(
I haven't open sourced them because I doubt anyone would care about those old MS-DOS/TP7 tools now, and I'm not up for maintaining them.
quinn (https://github.com/MrPowers/quinn) and chispa (https://github.com/MrPowers/chispa) are the PySpark equivalents.
Built bebe (https://github.com/MrPowers/bebe) to expose the Spark Catalyst expressions that aren't exposed to the Scala / Python APIs.
Also build spark-sbt.g8 to create a Spark project with a single command: https://github.com/MrPowers/spark-sbt.g8
That is why this Redis Operator was born which can be considered as a Kubernetes native implementation of Sentinel.
I hoped some day to make a business from it :)
Even if I was not able to find any users/customers, I learned a lot: proxies, Golang (encryption, networking, parsing), etc. I started writing it using Ruby, but accidentally got a chance to write in Go for few weeks... and I fell in love with Golang. After 10+ years of Ruby/Rails I thought I'm done as a programmer. But with Go I felt that I love writing code again :)
Building Vaulty was also useful when I wanted to contact some security/fintech company.
This is how I decided to join https://moov.io as SW engineer and continue my journey with Go lang (and fintech and security).
It's been out for a week and got ~ 400 users so far :)
Before, I would have to use a google sheet with the same information. I'd first make a copy, because you weren't allowed to edit the original spreadsheet, add filters for the columns I wanted, find out where the comedy night was, only select it if it was convenient, and finally sign up.
This was too slow for me - I'd be spending an hour a week managing where I was performing, opening dozens of Chrome tabs, and getting frustrated when travelling hrs to a venue on the other side of London. So I built the site to make my life easier!
Source: https://github.com/apuchitnis/open-mic-nights More details: https://twitter.com/apuchitnis/status/1391122602920382469
You can connect to Twitter stream API which is about %1 of whole twitter (was mentioned in their forums) and you can connect to Twitter Filter API with predefined hashtag monitoring or users monitoring and get all these related tweets.
Twitark creates daily rotated zip archives for each day structured in folders where each minute of tweets is set is a JSON file.
An archived day of Twitter stream API is about ~2GB per day.
I use this to analyze big data and trends with Twitter, also for past data. So far it is working very well and I've been working on database adapters such as Postgres, Sqlite which are on different branch (not yet committed to master) so you can write directly to your database instead of zip files.
The second open source project I released is actually being used in Twitark. It called Joebear (play of words of Jobber) https://github.com/pantchox/joebear
Its a Node.js serial queue manager, using old school Node.js event emitter. The goal of Joebear is to receive a list of jobs and run one by one, if one fails there is ability to reset or stop at any given time. In Twitark it is being used to monitor the Twitter Trends API.
I still hope more people will make use of my open source projects, I really invested time to write the documentation as well, but I don't have many stars on Github.
I tried using the paid ones like NetSpot but I preferred more flexibility not to mention their app did not work properly on my Android 11 device and I preferred a more opensource approach.
I tried an open source tool made by Jason Antman called Wifi survey map [1] but it did not have support for multiple APs and does not support speedtest benchmarking.
I just felt that other extensions lacked polish. The UX wasn't very good, or they didn't read all npm config properly.
I used it during my PhD to automatically instrument benchmark programs for several different software verification tools (there is some form of standardization going on, but there are still a lot of corner cases where the same program will be interpreted, and thus verified, differently by two tools).
It's written in Python 3 and uses pycparser to do most of the heavy lifting. Currently it's a bit on the back burner, but I hope to come back to it soon-ish. Some desiderata:
* pycparser's AST API is not terribly efficient when you have to rewrite large subtrees, but I don't know if there are any nice alternatives. * That's probably a pipe dream, but I wish there was some easy-to-use library to get semantic info about C programs (like a symbol table). That would help me "teach" the tool some neat tricks, such as SSA.
By the way, thank you OP, as your post convinced me to make the repo public.
I created a C++17 HTTP client which is backed by curl and libuv (linux only! sorry windows). I think a lot of people have done this or something similar but almost all of the ones I looked at either exposed the curl api directly in some fashion or had extremely weak async support. So my main motivation was extremely easy asynchronous queries for high throughput with a very modern C++ API that has as good as you can get memory safety, or at least as good as modern C++ will let you get. No raw curl calls or api exposed at all. I used to find it extremely difficult to make C++ HTTP calls, now its a real breeze.
My next project is a bit more ambitious: https://github.com/jbaldwin/libcoro/ -- I'd like to make a C++20 HTTP client from the ground up with first class coroutine support, and I'll be using lift as a benchmark to beat performance wise.
I'm still developing the library because ... I don't know why. I've lived with it for so long now it's become a bad habit I can't shake. I'm also quite proud of it because it can do things that other libraries can't do[2][3].
[1] - website - https://scrawl-v8.rikweb.org.uk/
[2] - Shape, and animate, an image between two paths - https://codepen.io/kaliedarik/pen/ExyZKbY
[3] - Filter over a live media stream - https://codepen.io/kaliedarik/pen/OJNVaEX
Pretty old projects, built during my years in the university. But also one of the proudest projects I achieved.
Last year, I decided to take the leap and try selling my first piece of software. Here's the PH launch from a few months ago [1]. It's not easy tracking down users, but I've managed to sell a few hundred licenses so far.
It has been a fruitful journey. Learned a lot while building it (e.g. about accessibility features on Macs), but making this a product also meant learning about licensing, payments, front end for the landing page, SEO and FB ads.
So I built Backtest to scratch my own itch. It's been growing more or less organically for the past 1.5 years though and currently sees about 500 visitors per day.
I'm thinking about open-sourcing it but I've yet to thoroughly analyze the pros and cons, and decide on important things such as the license.
[0]: https://backtest.curvo.eu [1]: https://www.portfoliovisualizer.com/
It's main purpose is for running challenges of jeopardy style ctfs.
- cachew: library that allows to cache python function calls in an sqlite database with just a single decorator (leveraging on type annotations) https://github.com/karlicoss/cachew#readme
- dron: a friendlier 'frontend' for systemd which allows me to declare jobs as python code living in the same file -- combines best bits of systemd and cron https://github.com/karlicoss/dron#readme. I elaborate a bit more on motivation for it on my blog https://beepb00p.xyz/scheduler.html
I’m trying to figure out how to market my app as a tool for desktop dynamic image generation. My app is kind of like bannerbear but for the desktop. For example, you can import a XLS or CSV and batch generate images from the data. That’s the essence of my app. It just so happens that “printing labels” is the marketable niche.
I’m selling licenses using a custom system I built using stripe/JWT and even do a subscription with expirations. It’s been a blast.
Revenue from MRR is in the thousands and one-time licensing sales is 6 figures. I couldn’t have built this without the awesome OSS JS community.
You can download my app here: https://label.live
I love a quick, keyboard driven application and I also have good codebase to use as a testing ground for CI/CD, code analysis etc.
Two weeks ago I actually got my first customer buying a license for it, after being in development for 9 years!
2. Puppeteer Camera: I needed a solution for recording Twilio live video and hosting it myself in S3. I made a docker container that launches Chrome headless, points it at any website (including a Twilio video conference) and uses a Chrome extension to record the browser screen and stream the video to S3. In theory it could be used to record any website on the internet.
[1] https://github.com/ted-piotrowski/react-leaflet-canvas-overl...
I also built a time tracker library that tracks how much time was spent on the current open tab. It also detects when the user moves away from the page or comes back.
Actively - https://github.com/arkokoley/actively
For a GIS project, I needed to extract county level data from NASA's MODIS dataset. Wrote a bash utility to do that: https://github.com/arkokoley/modis_county_cropper
Also wrote a boilerplate latex template for Academic homework: https://github.com/arkokoley/latex-homework-boilerplate
[1] https://en.wikipedia.org/wiki/Unix_philosophy
[2] https://github.com/paysonwallach?tab=repositories&q=amber
I've also created my very own static-site generator. Why? Because I don't like hacking around existing solutions with glue and tape to fit my own needs. So I've created something that I feel comfortable using (and doing that for ~2 years already to manage my personal website): https://github.com/writteli/writteli
In addition to that, I'm slowly working on a destkop app that will be compatible with my static site generator - think about Desktop CMS that produces you a static website in the end.
* the core idea is to selectively use training instances to learn a compact versions of a model. Multiple models are produced with different tradeoffs between accuracy and size. The user is then free to pick one that fits his needs. See [2], [3].
* one can also find the "minimal dataset" a models needs to reach a certain accuracy - [4].
Currently working on:
* I am reformulating the problem to work with (twice) differentiable losses to speed-up the compaction process.
* Also, I am looking multiple "stages" of compaction to see if that leads to models with further reduced sizes.
Refs:
[1] https://compactem.readthedocs.io/en/latest/
[2] see how the model's generalization is affected, also has accuracy vs size curves: https://compactem.readthedocs.io/en/latest/key_ideas.html#wh...
[3] Compaction profile - a plot to visualize the range of size reductions between the original and compacted models: https://compactem.readthedocs.io/en/latest/usage.html#compac...
[4] https://compactem.readthedocs.io/en/latest/usage.html#optima...
https://commandeer.readthedocs.io/en/latest/
I was fed up with having to build the nth argparse parser and instead used my already existing python functions to create the cli for me.
Features include: Full CRUD, geoquery support (bbox, radius, custom wkt polygon) complex_resources (aggregate & sub queries), middleware (access the query before db execution), permissions (table/view level CRUD configs), field redaction (enable query support -- without publication), schema migrations, auto generated openapi3/swagger docs, auto generated proto file, full validation.
GitHub https://github.com/sudowing/service-engine
YouTube Overview https://www.youtube.com/playlist?list=PLxiODQNSQfKOVmNZ1ZPXb...
The pair of server and browser libraries (with a third TypeScript types library) supports IE10+ and get WebAuthn down to four method calls with a small handful of arguments. And since the libraries take care of JSON serialization devs don't need to think about how to get random buffers from the server to the browser and back.
If this means anything to you the server library is FIDO-conformant. It's not FIDO certified but it's pretty darn close, and will handle just about every WebAuthn use case you can think of. There are still things the server has to do to properly incorporate WebAuthn support, but the work I've done significantly reduces most of the common stuff to a couple of libraries you can `npm install` and go.
So instead of writing all that custom each time, I wrote a SaaS starter kit to build from, and decided to polish it up and also release it as a full-fledged product:
Nodewood: https://nodewood.com/
It's helped me to be more rigorous when building out features (if it's going to go into a framework that others are going to use, it needs to be well thought-out, tested, etc), and is there as a stepping stone for future businesses I want to work on. It's been really satisfying to build out for the past couple years, and I'm closing in on completing the last few features and adding sufficient polish so that I can take it out of beta.
I've worked with Kafka since 2012, ran a consultancy delivering systems built with Kafka and Cassandra for a while, and eventually realised our experience could be wrapped up into a great tool that covers everything Kafka from clusters to schema registries, kafka connect and more.
There was literally nothing in the market when I started, so I built what we (and our customers) needed. Originally kPow was going to be a replacement for Datastax OpsCenter but it became pretty obvious in around 2017 that Kafka was going to be more widely adopted (and tbh I love the streaming compute paradigm / kafka streams / etc).
I work with another engineer now and we spend all of our time chatting with users, shipping features, working in Clojure[1], it's a blast!
[0] https://kpow.io
The repo contains the original Perl and JavaScript code for reference.
I also wrote a small library to deal with time in an AD&D setting. This library is also in Swift and the code is quite clean I think: https://github.com/wolf81/Harptos
I built both libraries to use for a game, but I never finished it: https://www.youtube.com/watch?v=TsqMGCWeD6I
At some point I hope to do a re-write in LÖVE 2D.
---
Most of the times, the libraries/tools that you build yourself are either to connect and interact with a specific external service OR to have a simpler (only the features you need) or cheaper version of an existing product/platform.
[0]: https://www.usertrack.net/
Same principle above for PDF file that you dont want to expose online : GUI to add page number to PDF: https://pdfpagenumber.com
GUI to reverse PDF page number order: https://apps.apple.com/us/app/reverser/id1440371872?mt=12
And most recently a ping checker on mac menu bar (so that I can know if connection problem happens during Zoom meeting while WFH) : https://simpleping.fluffy.es
Took me a few years to get round to publishing it, but although it never really took off (I am not exactly a natural promoter) - it's still the best way I know of to write capable, easy to maintain android apps - and nowadays the concepts are much more widely understood by your typical android developer.
I still keep it up to date almost 5 years later. It's 20% code: 80% sample apps and docs explaining why it works
https://github.com/agentultra/DataVersion — type-directed data migration library. I needed to migrate some data in a document database that had no schema with years of data in it to a format that had a schema. I leveraged some other stuff to achieve it but this library was a key piece to being confident that the transformations were correct and complete. Migrated the database and backfill it with a Lambda function using this library.
Those are just the most recent ones.
Another tool that I wrote (and have used quite a lot) is ElastiCluster: https://elasticluster.readthedocs.io/ It's a CLI tool to deploy compute clusters (of different types (well, it's basically a large collection of Ansible playbooks with a Python wrapper), but mostly focused on batch-queueing systems) on IaaS clouds. There's now multiple tools for doing the same but I think this one is still one of the few (if not unique) to be able to deploy multiple types of clusters on multiple clouds.
I also made some visualizations into the internals of QR Codes: https://www.nayuki.io/page/creating-a-qr-code-step-by-step ; https://www.nayuki.io/page/optimal-text-segmentation-for-qr-...
Telegram bot to deliver new Hacker news comment replies: https://github.com/golergka/hn-comment-bot It's hosting is broken and I've been meaning to fix it in the last month or two, but the code is working.
I built it because at the time there weren’t any good FIX library written in JS/TS and because I wanted to learn how it works.
AudioWrangler: https://apps.apple.com/us/app/audiowrangler/id1565701763
Got sick of my Mac using the wrong audio device when waking up, so I wrote a little utility that lets me prioritize which devices to use based on what's connected. It's my first app on the App Store. I'm enjoying learning Swift and using it to write desktop apps!
In the past:
* Lucid: https://github.com/mattgreen/lucid.fish
A pure-style prompt for fish shell that pioneered truly async fish prompts. Still use it daily.
* Fogeybot: https://github.com/mattgreen/fogeybot
A Discord bot for Heroes of the Storm that creates teams for pickup games using player ratings.
https://chrome.google.com/webstore/detail/reformat-gmail-inl...
It's basically a compressing of the copypaste+"quote-button" thing that people do. I reply inline quite a bit, so I've found it useful.
Just made this too (and am pushing a quick update soon) - it tracks how much time you spent on each chrome tab, and when you hit Alt-T it gives you your tabs, sorted approximately by time spent recently, so you can find your place better. https://chrome.google.com/webstore/detail/historia/hfibppfil...
Why? I wasn't happy with the pattern of hooking data loading into a router, and having to load all data needed for a page upfront at the route level and then plumb it through. I just wanted a way to let components specify what data to load themselves, and then do it on the fly as they render, whether on the client or on the server.
It still surprises me a bit that React itself never built in an async lifecycle method for server render that would solve this problem. React Frontload basically acts as a polyfill for that feature - it's been slowly ticking up towards 500 stars over the past couple of years, so I can't be the only one who finds this useful :-)
Then there is "null", also because I couldn't find one that got both, marshalling to JSON and be able to store null values in db: https://github.com/emvi/null
And finally, our "flagship" open-source project Pirsch, an embedded library for web analytics: https://github.com/pirsch-analytics/pirsch
On my free time I love to do some apps and when I started to learn Swift and Cocoa, I got tired of dealing with same things with platform specific complicated stuff.
I decided to build by own GUI tool, written with the Go programming language.
A couple of iteration later (years), it became a WebAssembly library for building progressive web apps.
It is named go-app and you can see how it look like with this dogfooded documentation website: https://go-app.dev
If you like lofi music when working, or you are a fan of World of Warcraft game, there is those 2 others ones built with this package: https://lofimusic.app and https://murlok.io
Hope you find it interesting :)
0: https://github.com/ianozsvald/ipython_memory_usage
1: https://github.com/ianozsvald/ipython_memory_usage/blob/mast...
https://thebreakfastpost.com/2018/05/18/repoint-a-manager-fo...
https://github.com/cannam/repoint
I wrote this because, as is normal, I was slightly dissatisfied with all the options I could find that would work with the language and hosting combination I happened to be using. I use it for a number of projects now and I have to say that it's really quite good.
It's written in Standard ML, which might tickle a few HN readers.
agr: https://github.com/nathants/agr
like ag or ack, but with the ability to replace matches or delete lines.
tinysnitch: https://github.com/nathants/tinysnitch
a minimal system firewall for inbound/outbound connections with visual prompts on connections without an existing rule. fails closed.
cli-aws: https://github.com/nathants/cli-aws
a cli for working with aws, particularly ec2 and lambda, that dramatically simplify operations. currently exploring a go port.
bsv: https://github.com/nathants/bsv
a binary data format and composable tools for maximum performance data processing. several tools have triplicate implementations in go and rust for performance experiments. generative testing with small and varying buffer sizes ensure correctness. prototype with pipes, optimize with a single binary (see related posts in readme).
s4: https://github.com/nathants/s4
maximum performance distributed object storage with adhoc distributed computation and data shuffle. duplicate implementations in go and python, for fine grained objects prefer go, for medium and coarse grained, use either. use with ephemeral data and instance local storage (i3en). prefer vendor object storage for durability.
A few things in there:
* `HibernateQuery` - wrapper around hibernate jpa implementation, because using the jpa criteria api is verbose as hell (seriously, even for java). Coming from having written Django, I wanted the ease of using Querysets in java
* Makemigrations - this seemed to be a missing hole in the java ecosystem. Our contractors were hand-writing sql migrations and using some framework that just ran them. Liquibase exists for managing migrations, hibernate can generate the schemas. This library is a dropwizard command to generate yml to migrate the old schema to the new one.
* generic pagination bundle
It's available here: https://github.com/uktrade/s3chunkuploader
Other packages are html meta tag parser (https://github.com/harel/metatron) and a python smtp wrapper (https://github.com/harel/strudelpy)
It's useful for various sysadmin-related tasks, like checksumming an entire directory tree, finding the file(s) that are different between two directory trees, or tracking file attributes in git. Since it's text-based, it's really easy to process using sed/grep (the file format is specifically designed to be regex-friendly).
I wanted a tool where multiple translators are integrated and where I can get translations from different sources but only using one tool. I then tried to build a cross platform mobile app using python (which is not the best language for this, I know) https://github.com/nidhaloff/Translator-pp
Probably the best project I built/started last year is the machine learning package igel: https://github.com/nidhaloff/igel
One of the projects I failed to make money with but that I'm still proud of is lychee.js [2] - it used game engine concepts to build a generic graph/scene for "normal" applications.
But the twist is that every state and property can be serialized, deserialized, and reconstructed over the timeline even with differential analysis (e.g. in error cases) or even predictions via tesselation and extrapolation over the multidimensional timeline. It uses techniques similar to flow based programming, but only to be able to vectorize the data in order to make it learnable by neural networks.
I got to a point where backpropagated ES/HyperNEAT was able to understand composite pattern based programming, whereas the entity/components were the adapters for the multi-agent based simulation layer and it could learn all kinds of cool things from layouting up to combinatory things of state management, where the neural networks could iteratively progress up until the final (defined outcome/goal state) was reached. Something like "animate this to that position" or "resort the grid layout based on user interaction" was automatically done within seconds.
The biggest project I built with it was a simulation that was learning the RAPID programming language, and was able to redesign a complete car manufacturer virtual factory, including all variables on the robot cell's code.
Then decided to take this into the cybersec sector, by letting it learn the combinations of exploits and definition/generation of payloads similar to how metasploit does it in a manual manner. Won a DARPA contest by writing an adapter for it, got classified and had to delete at least the AI parts behind it after a long legal battle that I, as a private person, could not sustain.
Suffice it to say I'm not allowed to work on it anymore, so these days I'm trying to fix the peer to peer web with compositional game theory ideas I have in mind for a while now. [3]
[0]: https://github.com/deathwebo/tinydiamond-timer [1]: https://deathwebo.github.io/tinydiamond-timer/
Also created https://jsonip.com. Get your IP address in a json object. I created it a decade ago to solve some problem I had and have been running it ever since. Last I checked it’s supporting 4-6 million requests per day from a pretty wide group of users.
It's really fun having a tool that I created get some use.. I've benefitted a ton from the OSS community, so it's nice to be able to have that relationship go the other way, even in a small way. Plus, I've learned a lot about Swagger/OpenAPI, and the many quirks of Amazon's seller-facing software.
The irony is that I never finished the rewrite, but the library was helpful to other Swift developers so I've been maintaining it since.
IIRC, I started out with Android Studio's dump viewer, but I wanted to check a "nested" attribute (.x.y.z) for all instances of a class -- and there were several thousand instances. I quickly tired of expanding and scrolling the nested attribute lists.
I think I also tried MAT's OQL, but still missed the ability to add whatever logic I needed on-the-fly.
My "Show HN" post got no traction, and I don't think very many people have used it, but I'm still proud of it.
A web application that is a one stop platform for you to log all your problem solutions, system design and technical learnings.
“You have only learnt something if you can articulate it”
This quote is so accurate. We often just finish a problem and are done with it, and when we see a similar problem we are not able to solve it. This happens because we have not analysed the problem and the only way we can truly understand the solution is if we can articulate it. One other reason why logging your learnings is needed is that we can always come back to it and find all the collection at one destination. We need not google everything from scratch again.
We are just starting off, but we are working to grow this into a one stop application to journal all your learnings. Come check it out.
logctl.herokuapp.com
[1] https://www.chromium.org/developers/tools-we-use-in-chromium... [2] https://chromium.googlesource.com/chromium/src/tools/grit/
It actually consists of two projects (and I'm looking into making them more independent): the server component, which lets you set up your service using an OpenAPI spec and simply write a number of functions, each handling one operation; and the client component, which does the opposite by taking the spec and letting you call the service with simple constructs like client.operation_id().
[0]: https://github.com/MH15/neanderthal [1]: https://matthall.codes/ [2]: https://kwest.haus/
There is a single abstraction (the Swarm) which is capable of modeling communication, NAT, and identity. And you can layer them (Swarms) to provide whatever functionality you need. For the most part, you communicate using tell or ask methods.
The big name in this space is lib-p2p. It doesn’t have a UDP transport (it exists but is incomplete), and the examples were focused on manipulating streams so it wasn’t clear how to model message based communication from reading the docs. You also have to buy into many other abstractions when you use it e.g. multiaddrs.
I also built a supporting tool to parse SOQL queries to support Jetsream because everything open source was broken and really sucked. https://paustint.github.io/soql-parser-js/
I added an asset manager so I can mix and match while creating AR stuff and then directly export it as a single file so I can archive it. I mainly use it to create AR experiences for friends and family (think, interactive birthday cards or for example, when MyHeritage launched their animate old photos, I used those animations on top of image based tracking)
I might turn it into a SAAS platform for marketers, but even if I don’t I’m going to open-source it either way.
The only thing holding me back is deciding what to name it. If anyone has a nice suggestion, I’ll open source it right away
It has a "TweetDeck" look and supports multi-accounts.
A low-memory Unix map-reduce combinator - https://github.com/vlad17/slb
A sparse matrix parser (cpython equivalents are not parallel) - https://github.com/vlad17/svm2csr
A personal task planner when doing high-risk work which minimizes time to failure - https://github.com/vlad17/fdd
Serilog.Sinks.InMemory for help with unit testing log messages etc: https://github.com/sandermvanvliet/SerilogSinksInMemory
TestableHttpClient to make testing API calls easier by providing a simple way to configure responses and behaviour as well as asserting actual calls: https://github.com/sandermvanvliet/TestableHttpClient
Both I think equal parts not invented here, “how hard is this really?”, not finding something at the time and just doing it for the fun of it
I really enjoy writing stuff like this that makes my day at work easier. There were formatters for a full summary, and there were pretty formatters for all errors. But we had so many warnings in eslint that it polluted the list of errors.
So now you get summary information for the warnings, and full (and pretty) information for the errors.
I’m also writing a desktop version of Jira that works fully offline. Because I just cannot deal with the web UI slowness.
I had built one for the product I was working on, but I wasn't sure if I wanted to open source it yet and give it away just yet.
It lets you set call limits on function calls, and various counters within a library to have a "demo" period. I built it because I didn't want to stand up a service that I'd have to maintain.
Libmon handles providing tokens for customers. It integrates with Gumroad. So you just need to create a product page, drop in our library into yours and set your limits, and you're good to go.
It's written in C# and runs on top of WPF: https://tinyurl.com/upbeatui
I also built an Apple Watch that set a timer by adding prime numbers up to 59 minutes. That was fun to do as an experiment. I use more often the other way of setting the timer: by choosing the end time. It’s faster than the default app and when I can’t use Siri.
https://github.com/inaka/worker_pool - A pool of workers
https://github.com/inaka/elvis_core - A linter for Erlang
https://github.com/adroll/rebar3_format - A formatter for Erlang
https://github.com/adroll/rebar3_hank - An oxbow code detector for Erlang
1: https://github.com/RonitRay/ecstatic
I didn't know Ruby (for Jekyll) or Go (for Hugo) and while you may not need to know them to get started, I didn't want the learning curve or bulky dependencies to cause friction in the workflow. Also, I just didn't like any of the standard templates and didn't want to think about how I would edit them to suit my needs.
Solves a common problem in the enterprise world - you have a big monolith UI stack with multiple apps, and starting it in dev mode gets slower over time. Lots of companies just allow you to start one of the individual apps, or they start splitting up the stack. This speeds up starting the stack for a developer, since all the apps get "browserified" on their own thread.
all the other stuff is in my bio :)
Fast spectrogram generator for wav files: https://github.com/axegon/spectrust
Static site library/framework thingy: https://github.com/Rorigami/rorigami
All practically abandoned for a million and one obvious and not-so-obvious reasons...
Pyranid - https://www.pyranid.com
I prefer SQL to ORMs and I don't like libraries with dependencies. Really simple mapping of resultsets to Java objects. Plays nicely with DI (I like Guice a lot).
Lokalized - https://www.lokalized.com
Another no-dependencies lib. I don't think any other platform handles translations in a powerful enough way. The magic is a simple expression language that lets the translator specify rules (e.g special cases for certain languages to be more "natural sounding") instead of embedding all that logic in code.
- JQ Live View (VS Code extension) [1]
Both used to create my game, a pokemon-ish roguelite (React, typescript) [2]
-- Links:
[0]: https://ldd.github.io/react-tech-tree/ [0-source]: https://github.com/ldd/react-tech-tree
It's a Python library giving utilities to handle data in Continual Learning, a subfield of Machine/Deep-learning where data comes incrementally. It's made to be super simple to understand, and can be used in fast prototyping on a notebook to large codebase.
There are others actors in the field that came atfer us and do more ads about their slightly similar library, but we manage to produce something useful to many PhD students, so that's a win for me.
It's not production ready and the libraries to do advanced authentication aren't there yet, but it gets past the initial hump of "I need to encrypt in-transit and not rely on my cloud provider's network links to be safe" (because they aren't)
https://github.com/JaDogg/sbx - flashcards console app (not sure if there are similar applications)
https://github.com/JaDogg/pydoro - pomodoro timer console app (I couldn't find such application)
I wanted to make a drop-in replacement for code review on GitHub that made reviews much more structured and focused while not requiring nearly as much clicking around and loading.
I built this over the last year or so, mostly on nights and weekends but I do hope it can become a full time thing eventually.
(Since we're talking about building here I'll mention that the app is 100% Vue 2 backed by Firebase. It's such a lovely dev stack and never keeps me up at night)
https://john.kozubik.com/pub/IcebergArticle/tip.html
"The purpose of the Iceberg format is to convey an idea in the medium of the web, but without the distractions of that medium. The author wishes to leverage the richness of a hypertext web of multimedia while avoiding the diffusion of a flat, non-heirarchical resource."
(with apologies in advance - this is a work in progress and even basic navigation might have issues ...)
There just wasnt a simple cross platform library with hardware support. (Anyone who suggests libav hasnt tried it outside of an statically linked demo app :)
Basically, just write a mutation, and a react form pops out. Fully customizable per form, or globally with context.
Just gotta finish validation, and give it some real good testing.
GitHub https://github.com/ericwooley/graphql-code-generator-react-f...
Website https://graphql-code-generator-react-form.thewooleyway.com/
https://github.com/dbasch/BIP38
And implementations of paper wallets for offline storage using it:
I originally implemented that for my rowlock library (https://pkg.go.dev/go.yhsif.com/rowlock) a few years ago. But there was some recent other work requires something similar, so I extracted the defaultdict portion out to be in its own library.
[1]: https://github.com/kevin-hanselman/dud
[2]: https://dvc.org/
At the time I only had experience with the OpenGL C api and didn't want to learn a totally different Rust abstraction or mix C/C++ libraries into a pure Rust project.
https://github.com/DomWilliams0/name-needed/tree/develop/ren...
Now I use the same to check if my websites are running properly :)
I call this project little lambda puppets and it deploys puppeteer script on aws lamba in one click and comes with inbuilt telegram api integration to send out alerts and cron. It has served me well for almost over an year now.
Some of these items are in production environments. I plan on releasing it open source (fully) once I get around to it. It's really useful.
https://github.com/jodavaho/kda-tools
- a layperson microblog engine PoC https://demo.mro.name/shaarligo
- a radio recorder for Bavarian public radio http://rec.mro.name for personal use (legal issues, ugly to install)
I built it to have something simple and lightweight for discussions for remote teams, as an alternative to meetings and using more heavyweight methods like issues for conversations. It is still early days but there is a free tier, if you are interested and check it out I would love feedback.
So my library simply allows you to define a set of exceptions, with a distribution across them. The app runs an extra thread in parallel with the main app, and "carpet bombs" the main app with exceptions drawn from the desired distribution.
Very useful for checking that the code is resilient to all sorts of real world edge cases you haven't thought of!
The source can be found here: https://github.com/powerworld/TDSToPDB
`humanlog`: - When you tail JSON or LOGFMT logs and want to get nice colored logs. https://github.com/aybabtme/humanlog
`datagen`: - Until Go has generics, this tool generates common datatypes such as sorted sets, sorted maps, queues, heaps. https://github.com/aybabtme/datagen
Also convinced the company to make it the first and only OSS project there.
[1] https://github.com/Trinovantes/userscript-youtube-playlist-o...
It started as a guitar fretboard exploration tool that did not survive, but I ended up publishing it as a reusable component.
I also made Creepyface, a JavaScript library to make your face look at the pointer:
I originally developed this to use it in my resume, and then ended up building a site for it and a plugin system to make faces even dance.
I built [Sane][0], which is a single-file library without dependencies, that is basically a decorator definition and a function export.
https://github.com/pterodactyl/panel
Kind of took off after posting here about it a few years back, and now it just kind of sustains itself with some bug fix inputs every now and then.
I recently started building Green Things because I wanted to get into gardening more. My plan is to be able to suggest plants to grow based on location and companion planting. https://green-things.thomasstep.com/
Around 2005 I got myself a Casio ClassPad 300, which was like a strange combo of a calculator and a PDA. It had a big B&W touchscreen with a stylus. It was the first Casio handheld that came with an official SDK to build native apps for the device; before that it was only possible through pure reverse engineering and hacking -- good times. :) So there were 2 options to write programs for this device: you could either code in BASIC directly on screen, which was easy but very limited and suffered terrible performance -- or you could use a computer to write and compile a C++ add-on and then transfer it to the device, which was extremely powerful but of course a lot more complicated especially for beginners.
So here is what I did: I took the C code of the Lua 5.1 interpreter, embedded it into a new C++ add-on, and then I made it possible to write and execute Lua code directly on the device through this add-on. I even made a new custom font for the text editor and a new virtual keyboard for the stylus to maximize the amount of code visible on screen. I wrote my own memory block allocator for the interpreter to provide access to additional RAM space, among many other hacks. But more importantly I made most of the features of the SDK accessible from Lua scripts, which means it was then possible to write or read persistent files, draw any kind of figures on screen, create user interfaces using native UI components, use advanced math features, send data packets through USB etc.
The project quickly got a lot of interest inside our small community: now you had a third option for coding, offering excellent performance, lots of advanced features and it was very easy to start with. It was the first time I built a tool incrementally based on user feedback instead of building it just for me. Even the maintainers of the SDK and official apps followed the project closely. Eventually I moved on and never got the chance to actually implement everything I had in mind. I learned a lot, had lots of fun, and this experience has been key to the identification of my ideal career path.
All of these where easily scriptable, but I needed a way to run it everywhere. Hence multi-gitter was born.
The story is that I have spent decade writing a JavaScript UI library, I was hired during early days of jQuery movement, pivoted several times (html + images, html + css, flat html + css, canvas, canvas + webgl) however end up with unused tools and UI kit, few years later, during 2017 I have decided to rewrite some tools using Typescript and release as GPL2 (which I should change to LGPL2) and changed career.
I’ve been thoroughly enjoying using Kotlin for backend development for a few years, and gave coroutines a chance this year. Feels great to open-source something that’s been privately useful, and hopefully contribute to the wider ecosystem.
Post: https://middlemost.com/failure-is-your-domain/.
Library: https://github.com/Vanclief/ez
Initially, I needed to create such QR and hadn't found any publicly available js lib, so I created one by myself.
The idea is that you have a form field-like command that you can record a response with. You can then submit the video via a regular POST request.
I couldn't find any simple tools like this for rapid prototyping different survey responses and experiences. It was fun to build and nice that some people have starred this on GitHub!
Existing tools require logging in. But this just does the job.
The code is open sourced at https://github.com/theankurkedia/openpad
[0] https://github.com/leifg/formulon [1] https://formulon.io
npx @nikhilverma/ast-grep '{ meta: { title: "___" }}' src/
This will search for any object with a key meta which is also an object and has a property called title which is any string. It uses AST for grepping so you don't need to worry about placement, whitespaces etc.
It essentially scanned all the R files in a given directory and generates a file with all external packages that are used by the program.
Its super useful when the R code/ directory doesn't have requirements.txt or basically list of packages that need to be installed.
I don’t like nginx because managing the config files is a hassle, it’s complex, and there’s a lot of copying redundant config files over and over again.
If you have a C++ static lib in CMake, it takes two more lines of CMake to generate a Python extension module, and a single line of annotation per C++ function that you want to export.
https://github.com/bebump/bbmp_interop
I use it mostly for testing numerical C++ code using Numpy and Scipy.
To fix this I wrote a Drupal "input filter" called Pathologic which basically found all internal links in content and tried to rewrite them to point to the same content on the "current" site (which would be the live site after the article was published there). Eventually, after feedback from others, it could do other tricks like rewrite absolute paths to relative ones and vice versa (so your paths could be relative in a web browser, but absolute when the content was published via RSS feed or email), make sure http:// vs https:// was sorted out, and so on - broadly speaking, its goal was to make sure that links to internal content were always correct in all circumstances, and except for a few bizarre edge cases (there were always bizarre edge cases, though I'm glad to say they got exceedingly bizarre as the project matured), it met that goal. It became quite popular in the Drupal ecosystem and was my most successful open source project by far in terms of the number of users.
Sadly, in recent years, I haven't been able to work with Drupal except for either small personal projects or projects that ended up failing before launch, so the code is now in disrepair and won't run well on current releases Drupal 8 or 9 if it runs at all. I'm hoping some day I'll be commissioned for a new Drupal project again and have the motivation to get it updated, but for now it has rotted. I'm still really proud of how many people it helped out in its heyday, though.
Azeroth Weather an app which shows you the weather and the coresponding WOW zone - https://www.azerothweather.com/
Or I made Splitstream where you can watch multiple twitch streams at once - https://splitstream.net/
Nothing fancy but I'm proud!
https://github.com/LeapingGorillaLTD/Testing
I was fed up of having to substitute every dependency manually whenever I wanted to write a test, finding it hard to apply clean software design principals to test suites.
When making a decision, it allows adding a pre-processing stage to the input before comparing it with the following possible branches of the tree.
https://github.com/mwarkentin/django-watchman
When I wrote it I couldn’t find anything similar, although I’ve come across a few others over the years.
Out of the box, it builds something compatible with most browsers made since 1995, with and without JS, CSS, Unicode, and optionally supporting dynamic elements like commenting and private-key-backed user accounts.
It's nowhere near 0.1 yet, but I'm enjoying building it publicly.
I originally built it as a performance monitoring service (runs Google Lighthouse), then later expanded its capabilities to run uptime checks against HTTP/HTTPS pages.
Not open source, but I am planning on funding open source through the proceeds.
I was motivated after the redirect page “hung” several times in one day, and I didn’t fully trust some of the existing extensions.
https://addons.mozilla.org/en-US/firefox/addon/skip-google-r...
Also, a library to write tests with databases for Go: https://github.com/go-testfixtures/testfixtures
The lib - https://github.com/krtkush/LinearTimer
https://github.com/silb/jsrlib
I found downloading the JSRs manually too cumbersome.
It is acompanied by an Eclipse plugin that i never got around to publish on GitHub. It lets me right click a Java type in Eclipse and open its JSR PDF file.
I recently started to write more often, and having a consistent and surefire syntax helps a lot.
It started with custom anchors for header tags, table rows, custom classes for block quotes, highlights in code snippets, line break patterns, etc.
https://github.com/anirudhvarma12/rabbit-hole-webext/
Unfortunately, I haven't been able to get it to work on Mobile which is where a lot of my own random browsing happens, but I have been told its useful!
I wasn't satisfied with writing the YAML or annotations manually.
Uses a game loop to iterate over parameter collection.
I type something like “create kubernetes cluster” it checks for cloud creds or asks, and proceeds to gather the cloud providers params.
F5 saves state to JSON :)
It’s opinionated in that it only ever spins up a new account under an org. Blue/green accounts :)
Infrastructure people are insane to babysit all that (I used to be one).
It’s old man sysadmin rearing his ugly head again.
With on focus on performance with minimalist UX
https://gisteam.herokuapp.com/ https://github.com/hirako2000/gisteam
It's not open source but i am/will open sourcing its individual components
Also I've written my own logging library. Multiple times. Doesn't everybody?
Fantastic for writing unit tests where you want to quickly freeze API responses and such.
There is more it could do but it's hands down the best RoI in terms of dev time I've had in a while.
https://insightrend.com/?page=term-trending - like google trends but better
and https://ideasfilter.com/ a list of apps that you can copy and make money of
It’s a procgen algorithm that takes small image as input and generates a larger one with similar local features. I hope to add tiled method to the library some time.
https://github.com/jareklupinski/watchdog-email
planning on adding a timeout parameter soon!
It needs more love - I really should add more love to it... but it works fairly well for node and react apps!
Made it because imgur put an ad interstitial into its upload flow and I just want to be able make images available online quickly
"Interpret" C and C++ files: https://github.com/RhysU/c99sh
I wanted to avoid system dependencies (browsers). A nice side effect of that it's also the fact it's faster and produce smaller documents.
It actually has lots of improvements in the 6.0.0 pull request that i am delaying because i am too lazy (and haven't got much time) to fully rewrite doc.
- https://nostashapp.com I use it personally and I love to have my notes online.
- https://docutemplate.com actually work in progress to understand the API of googles.
- zefaker[0] - a CLI for generating (random) data and exporting to SQL, Excel, CSV and JSON. Has helped in generation of test databases and test data for various scenarios. Much more convenient than a tool tied to a specific framework. Also gave me a chance to learn how to work with the Groovy script engine.
- groupby[1] - A CLI tool to group files into directories, by year, month or even day. Originally started writing it in Rust but got annoyed when I kept losing fights against the Rust compiler/borrow-checker; eventually drove me to learn Go...
[0]: https://github.com/creditdatamw/zefaker [1]: https://github.com/zikani03/groupby
Lots of SSGs existed but none supported Svelte and I wanted partial hydration when people said it was impossible.
Probably a bit long in the tooth right now, am going to port to mjs in the next few weeks.
unfortunate name I guess, but it is what it is.
Lovingly documented and well maintained :)
after trying at least dozen C++ GUI libs and none of them being good enough (license, limited portability, limited customability,...) i started making my own one which is OpenGL based, got automatic layouting, separation of concerns of layout/style/logic, permissive license, and provides building blocks to make your own widgets. https://github.com/Enhex/GUI
https://github.com/joy-framework/joy
I wrote it because I really like janet and there wasn’t a web framework in janet yet, although I think there may be more now
- I built it because at the time, sync for iOS was a mess: Apple’s original CoreData iCloud sync was very buggy and often failed to sync. An open source alternative seemed nice but poorly maintained, and I wasn’t completely on board with the overall architecture of it. A paid library was great but also quite complex and I had no control over the direction, features, and longevity.
- Apple released their own alternative recently, although it’s only available on newer iOS versions. Additionally, I’m not in control of the CloudKit data schema, and I don’t have the ability to add more complex sync features if needed.
- underlying all of this: the need for control, reliability, and customizability.
So, I spent a few weeks writing my own system. It works well and despite a few hiccups that I’ve resolved, it currently provides reliable, seamless sync for an app with millions of downloads.
- My library is quite generic but I never open sourced it. It would be a nice contribution to the open source community, but I’m not sure I have time to consistently maintain it or review pull requests. I’ve considered it at times, but it’s just never been a priority.
- If sync ever goes wrong, I’m able to debug it and understand exactly what the problem is.
- I can add features any time I like. I plan to do so soon to support a few things that even Apple’s new solution might not encompass.
There are quite a few downsides to it too:
- I need to maintain it myself
- It probably has had less testing than something like Apple’s new solution
- I’ve occasionally shipped a small sync bug, primarily due to lack of ability to test at scale
Overall I think it was worth it, especially given that Apple’s new solution wasn’t available at the time. I learnt a lot; building a generic framework is a great way to grow technically.
If I had to make the same decision again today, I’d heavily consider Apple’s new solution instead, although I’d only choose it if I was confident that it is much more reliable than the prior option they provided.
Some cool RFID cryptography and some machine learning that had to be done on device (privacy and security reasons).
passportreader.app/
Pleased with the service and how it is so far.
2014: apdqc. asynchronous MySQL driver used for the cache backend. Simplicity of the stack increased our uptime. async db writes are quick.
Supports dynamic values, TOML configs, runtime mutations, merging and stuff.
I wasn't satisfied with note taking apps or the way apps own data when I prefer the flexibility of my data/structure having apps.
Creating an account is free https://flayyer.com
Basically just made for fun.
Uploading & downloading translations
It's a thin layer that wrap Go (Golang) SQL database driver, it does not change sql.DB usage in any existing Go app.
It is because I prefer to use vanilla Go sql.DB in my web service and I could not find any SQL logger for Go SQL database standard library that can use structured JSON logging.
Annoyed by amount of tooling required to render markdown, nunjucks and front-matter, I wrote this cli and used it for all of my static sites. Since then, I’ve mostly migrated my sites to nextjs.
Surprisingly, when looking at dependent projects, people tend to put it in their dependency tree for weird reasons.
For another project I was getting static HTML reports from a tool, which contained third-party styles and scripts that didn't work when the reports were accessed from 'file://' URLs. I asked on StackOverflow ( https://stackoverflow.com/questions/50339325/inlining-extern... ) but all the suggestions involved a Web browser or complex Javascript build tools. I ended up writing a little Python script to replace such third-party content with data-URI versions: http://chriswarbo.net/git/html-inliner
Many years ago I wanted to control some physical sensors/actuators using an Arduino, controlled via a complicated C++ project running on my desktop. I wrote a simple sketch for the Arduino which just reads/writes 'commands' over a USB cable, in a simple JSON format http://chriswarbo.net/projects/arduino (I then wrote a trivial Python script to shuttle messages back/forth between the USB line and the C++ program)
I like reading RSS/Atom feeds in Emacs, but my preferred reader only supports maildir. There are a few projects which can convert between these, but they all include 'databases', URL fetching, etc. which I didn't need. Hence I took one of these and ripped out all of the functionality I didn't need http://chriswarbo.net/blog/2017-01-14-rss_to_maildir.html
I've come up with a few scripts and Emacs macros for extracting metadata from PDF files http://chriswarbo.net/projects/pdf-tools.html
I guess it's not very useful.
We found out that many CRUD operations on CRDs were painful, so made a simple, yet useful, ORM. Don't hesitate to check it out !
https://github.com/jftuga/sqs_clipboard - Use AWS SQS as a clipboard to copy and paste across different systems and platforms
https://github.com/jftuga/gofwd - A cross-platform TCP port forwarder with Duo 2FA and Geo-IP integration
https://github.com/jftuga/spotprice - Quickly get AWS spot instance pricing
https://github.com/jftuga/ipinfo - Return IP address info including geographic location and distance when given IP address, email address, host name or URL
https://github.com/jftuga/photo_id_resizer - Resize photo ID images using face recognition technology
https://github.com/jftuga/tcpscan - A fast, simple, multi-threaded cross-platform IPv4 TCP port scanner
https://github.com/jftuga/date_gap_finder - detect date gaps in a CSV file
https://github.com/jftuga/nics - Display information about Network Interface Cards (NICs) - cross-platform
https://github.com/jftuga/deidentify - Deidentify people's names along with pronoun substitution
https://github.com/jftuga/quautomatrics - Command-line automation of Qualtrics™ surveys
https://github.com/jftuga/timeit - A cross-platform CLI tool used to time the duration of the given command
https://github.com/jftuga/dcmp - Compare files within two directory trees for equivalency
https://github.com/jftuga/file-watcher - Monitors a given file location for create, change, rename and delete file events
https://github.com/jftuga/compinfo - Display basic computer info
https://github.com/jftuga/less-Windows - GNU less compiled for Windows 10. Stand-alone version with no dependencies.
- kcup[0] serves a single page over HTTP/S (there's a version in go but I don't work on that, only created it to compare initially)
- async-wait-for-promise[1] - a tiny npm package for waiting on a condition or timeout (README contains why the certain combination didn't already exist)
- mailtrain-form-post-sidecar[2] - a little sidecar container for mailtrain that accepts form POSTs for mailing list signups
- redis-bootleg-backup[3] - a tool for taking backups of small redis databases with only read access (KEYS *-based)
- maille[4] - a component framework for mithriljs
- postmgr[5] - a daemon for running & managing postfix, dovecot and other mail-adjacent software (haven't worked on this for 2 years, because better options like maddy[6], chasquid[7] and haraka[8] exist)
Unfortunately, most of the stuff I've worked on that I've open sourced lately is instructional/pattern-related, so that doesn't really fit this mold, but in the background I've been working on what might be my biggest project yet (remains to be seen if/when I'll open source it) -- readysetsaas, a truly no-code (you provide configuration only) saas company creation kit, somewhat similar to AWS's SaaS boost thing.
[0]: https://gitlab.com/mrman/kcup-rust
[1]: https://gitlab.com/mrman/async-wait-for-promise
[2]: https://gitlab.com/mrman/mailtrain-form-post-sidecar
[3]: https://gitlab.com/mrman/redis-bootleg-backup
[4]: https://mrman.gitlab.io/maille/
[5]: https://gitlab.com/postmgr/postmgr
[6]: https://maddy.email
I've also build [sysend.js][2] (random name with send at the end). It's for sending messages between Open Tabs, It have nice API and it works in all modern browsers and even some older ones like IE11. I didn't know any existing library that did the same, that's why I've created one.
Another library of mine is [Tagger][3], because there where no Vanilla JavaScript library like this. I needed it for StackOverflow Q&A site that I've started, but abandoned and it was inspired by StackOverflow tag editor.
Yet another library is [LIPS][4], Powerful Scheme based lisp in JavaScript. LIPS is acronym LIPS Is Pretty Simple (at least it was when I started the project on [Codepen][5]). It started as lisp in JavaScript, but later I decided that I want fully working Scheme (compliant with R5RS and R7RS). I'm still working on Beta 1.0 version, that is like completely new project. I'm also still working on new website that will showcase beta version better.
I've also created [Favloader][7] - favicon animation library. [LILY][8] - Zero dependency, simple version of YARGS for parsing command line arguments.
[0]: https://terminal.jcubic.pl/
[2]: https://github.com/jcubic/sysend.js
[3]: https://github.com/jcubic/tagger
[4]: https://github.com/jcubic/lips
[5]: https://codepen.io/jcubic/pen/gvvzdp
[6]: https://lips.js.org/
I made a website builder and CMS, because the world really needed another one of those :)
> are they open-source
Not currently, but I keep wondering whether that might be a route to go down and how that may impact the ability to ever earn money with the thing. I know they are not mutually exclusive, but my main worry is that I am terrible at marketing what is (imo) a good product and I wouldn't want someone whow does know how to do marketing to take it away yet. Once I have a certain number of users I'll probably open source it. Or if no users show up, actually.
> why weren't you satisfied using what already existed
So many things.
- Most website builders rely on drag & drop blocks. Everyone loves using these, but in my experience it just leads to a jumble of blocks and components that behave erratically when asked to respond to different screen sizes. I went with 'modules' instead. Little, self-contained, (mostly) full width components that you stack on top of one another to compose a website structure out of it, this way we can control how components react to screen sizes much more tightly, making it much harder to mess up the design
- Most website builders also aren't running 60fps on my shitty Android (I'm not saying mine does at all times, but it probably does more often)
- Back in the day I just wanted to throw a quick static blog onto Netlify using the Netlify CMS, with quick, near-realtime previews of what I was doing. You could either get a sort of hacky realtime preview by injecting stylesheets into React components specifically configured for that purpose (which looked mighty impressive when it worked), or you had to wait for your git deploy to be picked up and shown as a preview, which took ages (or which feels like ages when you are iterating quickly)
- I don't like themes. They feel more restrictive than anything. I find that making large structural changes to a site is hard to do with Squarespace, Wix, Wordpress and the like. I think Wix even locks you into a theme once you've chosen one
- Hidden costs everywhere. Squarespace, Wordpress and the like are very good at making their services appear cheap and then very quickly trapping you into paying for all sorts of features. Netlify and Heroku felt similar. Like the amount Netlify charge for form handling suprised me.
- I wanted to see what my website looks like almost in realtime, and I wanted that preview to be easily shareable, so I built that
- I didn't want to think about hosting, DDoSes or anything like that, so I just deploy static sites to Cloudflare. Done.
- Documentation that covers the entire system, back to front, in both video and text. Try doing that with Squarespace or Wordpress.
- Lastly, I wanted something stupidly easy to use. Easier than any of the incumbents. It has to be so simple that complete computer illiterates would be able to develop an intuition for it in minutes. User testing I've conducted so far is telling me it's working, but I want to get more data on this
In the end I think my sites are just a little bit less pretty than the elaborate themes you can get with other providers, but they perform better, are faster, much easier to use and we try to not break the bank either. So it depends on what your needs are. I am under no illusion that I could ever rival Wordpress' or Squarespace's offerings, so I try to compete where they can't.
I must admit that pricing is something I still haven't figured out at all. My cheapest tier is (GBP) 7.99 a month. Is anyone willing to pay that nowadays? Tempted to add a free signup, with payments only coming into play once you hit 'publish' on your site.
Anyway, the thing is called the Pink Pigeon Website Builder & CMS[0]
I ended up finding https://datatables.net to take care of the front-end side of things and duct-taped that to a mini-ORM (https://github.com/schotime/NPoco) which came with a simple parameter-safe query generator and ended up with the ability to basically write 1 POCO defining columns and their metadata combined with 1 POCO that contained an in-code SQL query. Once defined, all a developer would need to do from the front-end is ask for the column POCO and suddenly a fully server-side powered table would appear with full support for (server-side!) pagination, page saving, export to CSV/Excel, column hiding/showing, column rearrangement, etc.
I had to write a ton of glue and learned a massive amount about SQL Server during the process. While the mini-ORM gave me a very simple way to inject things like the WHERE clauses and ORDER/SORT BYs, I ended up writing all of the actual logic to convert the request coming from DataTables to actual SQL. At first I thought I was writing an ORM, but really it was just a very specific use-case query builder.
Around the time I got that much of it working a co-worker put me into contact with a friend of his at another consulting shop nearby who he swore was doing the exact same thing as me but with Dapper (https://github.com/DapperLib/Dapper). A few beers and weeks later we had both sat down and evaluated each others work and decided to join forces. He ended up preferring NPoco and I ended up preferring a TON of his query generation (he also had support for basically all the non-complex types (read: hierarchy and friends), so it was an awesome merger).
In modern times, we've got to the point where you can now write a single C# class that inherits from our IMagicalQuery with a single SQL statement inside. Using the magic of Roslyn and a Visual Studio plugin we wrote for ourselves, you can smack a button and it will generate all the other supporting classes needed and update them if your query changes at all (one of our biggest problems was changing the query required you to change [DataAttribute] values on the matching column metadata class, which was very easy to forget to do and annoying).
We also have the awesome feature that came out of necessity of removing joins when hiding columns. Say we've got a 30+ JOIN query (yes, that is necessary for some of our clients; no, it shouldn't be; we don't always get to design the databases!) and the client hides 1 column out of 3 that depend on the JOIN Foobar table - nothing happens! But if they hide all 3 our magical query builder will drop that join entirely from the actual SQL that gets passed to the mini-ORM. The query in our C# class is untouched, it just deletes the offending join out before shipping it to SQL. We've been able to get some awesome performance out of that.
It is sadly never going to be something we release because the reality is that it is a monster made by two savages. Technically either of us can push it out at any time - we both agreed on MIT from the get-go as we both also agreed it's a hydra that no one would ever want to buy. That said we've both profited - our shoppe is now known as the one that can get you the data your people need 10x faster than the other guys. We do SMB consulting so word of mouth is king.
I probably made it sound all roses and kittens so let's talk negatives. 1) SQL Server only. We have tons of SQL Server specific dialect stuff because, well, 99% of our clients use SQL Server. 2) We only support the bits of SQL we need. Initially it was the basics: numerics, approximate numerics, datetimes, strings. Later on we added TVP support, some very limited spacial support, sql_variant. But it has all been as-needed. 3) Adding features that go up the entire vertical is...an experience. Pretty much only my partner in crime or myself touch that. It basically requires you to get the following into your brain: the entire DataTables API, the 5 or so ES6 modules that wrap around DataTables that handle type conversions, data conversions, query mapping stuff, etc., then the 20+ or so C# classes that do all the heavy lifting to ensure type safety doesn't go boom, SQL generation, all the magical performance features we added like JOIN removal, etc., then you also need to know how NPoco is using that data in case something goes funky there. I generally set aside a full day or two whenever we need to add a full-stack feature cause it's just a headache. 4) We write SQL in SSMS then literally copy paste it into a C# @"" string and then parse it with Roslyn later and rewrite it. I know exactly where I'm going in the afterlife...
For future stuff we are planning on a version that generates a stored procedure directly into a SSDT project so that we can actually store our SQL in a project that...is meant to store SQL (what a novel idea!). It would simplify our C# query to literally just be "EXEC
1. Pronto [0]: An "ORM" that mapped a protobuf to an object in MongoDB. The idea was to extend it to other storage backends (RocksDB, sstable, sqlite, etc) to make it easy for a service owner to decide what access pattern they needed and easily and efficiently map a proto to it. It wasn't too slow and was very intuitive for people to use since it only exposed a LevelDB-like API (Get(key), Set(key, value), List(filter)) and it made use of some of the newer features of MongoDB's libraries to do sorts and streaming on the client side. Really lowered latency and DB size requirements.
2. bazel_compose [1]: A tool to wrap Bazel, rules_docker, ibazel, and docker-compose to give developers a fast, hermetic, and automatically rebuilding/restarting local environment for development. You could essentially go to `http://frontent-a.localhost` in your browser and get routed to the right frontend.
3. branchpoke [2]: When I joined we had ~300 open branches per developer. People would hack something, push it to git, and forget about it. Some branches had critical fixes that were deployed before getting into master. Lovely startup things ;). I wrote this to send everyone a slack message once a week about 10 branches they had open that were over a month old in our monorepo. Over a few months we deleted most of the old branches.
Stuff I built at college:
1. Parking Analysis [3]: My college had an awful parking situation. I setup a cron to hit an undocumented API grab the number of spots open in the parking lots. I graphed those with a heatmap to find when our parking lot filled up around different holidays.
2. Butcher School [4]: A website used to "study" (memorize) the ARRL exam question set. It used some regex to parse the .doc file that is published by ARRL into it's json so anyone can create an updated set of questions. It also ran in local storage so you could study without internet on your laptop (like in the car on your way to Dayton). I built this for students who were having a tough time joining the Amateur Radio Club at NJIT (I was the treasurer). It's not the best tool by any means. It's just the most free (price and libre).
[0] - https://github.com/CaperAi/pronto/
[1] - https://github.com/CaperAi/bazel_compose
[2] - https://github.com/CaperAi/branchpoke
I'm not sure what the motivation for your question is. Do you feel like everything's been invented and built already, and it's just a matter of (at most) plugging the things together?
I find myself constantly thinking "this should exist". I don't have time to make them all exist.
https://github.com/ThomasHabets/arping
Nothing like it existed at the time, and I wanted to send ARP requests as easily as sending ICMP ping.
https://github.com/ThomasHabets/simple-tpm-pk11
I wanted to use a TPM chip for SSH client keys, and couldn't find anything like it.
https://github.com/ThomasHabets/tlssh
I wanted to explore what it would be like to have SSH, but with identities not based on providing username, but an x509 cert. (and TPM chip protecting the key) Also became a fun learning experience about terminals.
https://github.com/ThomasHabets/cmdg
I wanted to use GMail from a fast cli that used the native gmail API.
https://github.com/ThomasHabets/rslurp
I wanted to download concurrently and according to patterns. Ok, so honestly this one probably exists somewhere in a form that I would like, but I couldn't find it.
https://github.com/ThomasHabets/sim
I wanted multi-party authorization for sudo, and couldn't find one.
https://github.com/ThomasHabets/monotonic_clock
People kept using gettimeofday, so this is part of my compaign against it. (see https://blog.habets.se/2010/09/gettimeofday-should-never-be-...)
https://github.com/ThomasHabets/gtping
I worked in mobile core networks, and wanted a "ping" that used the GTP protocol since that won't be firewalled.
https://github.com/ThomasHabets/ind
I wanted my bash scripts to have automatic indentation, while not sacrificing buffering latency and such.
https://github.com/ThomasHabets/tlscheck
I wanted a simple tool to audit my TLS certificates for expiry.
https://github.com/google/huproxy
I was travelling to China on vacation and wanted a VPN out that would be unlikely to be blocked by the great firewall. Ok, so there are many VPN-like tools for getting through the GFW. Maybe it was just an excuse for me to write it. Honestly ssh -D would have likely worked just fine. It's being used by the keymaster project now though, so maybe it did something right: https://github.com/Cloud-Foundations/keymaster/blob/master/d...
https://github.com/google/tcpauth
I wanted to lock down SSH to anyone who doesn't have a secret key (and portknocking is usually ridiculous). Why not use TCP MD5 for it? https://github.com/google/tcpauth (MD5 is actually safe to use in this mode. It's not broken for all use cases) No firewall needed, and the TCP port is simply not open for anyone without the key.
That's what I can think of right now, after filtering the less interesting ones.
I also work on an XMPP library and related tools that has spawned other libraries for handling XML streams (basically duplicating all the functions in the io package but for XML tokens instead of bytes), a SASL authentication implementation, etc. https://mellium.im/
I have a ton more, but these are the two collections I more or less keep up to date and use the most.
To give an example of why I wasn't satisfied with the existing things, let's look at the library for migrations: prior to writing it I was using Diesel, but it didn't exist in many package repos and took literally hours to build on pretty good hardware (Rust is garbage in terms of build time, as much as I enjoy the language I almost never use it for this reason), and it had atrocious errors to the point that I'd call them bugs (I would frequently have errors that would spam the terminal with pages and pages of parenthesis, I'm sure they've fixed this, but at the time it was annoying). The various migration tools written in Go had similar problems so if I handed my nice single-binary application to someone to deploy on their own server I'd also have to hand them a zip file full of migrations and they'd have to figure out how to install a tool. Instead I wanted the binary to embed and be able to run its own migrations, so I wrote the library.
For the 2FA library it was a similar story: all the existing ones I could find had the abstraction wrong, they just did TOTP or HOTP and didn't seem to realize that they were the same thing just with a different "ticker" function. Having a simple 2FA implementation where you could create a token and pass in a custom ticker (or of course the package would have the TOTP one pre-defined) just "made sense". Also, the others I evaluated weren't tested very well. I wanted at least a handful of tests to make sure the tokens weren't going to break the next time I made an update.
Finally, for the HTTP router/multiplexer I wanted to be able to get the routes back out and match them to the URL components that matched various wildcards so that I could do easy normalization. Eg. if you had the route /u/{username string} and the URL /u/Me matched it, I wanted to be able to automatically redirect to /u/me. Most routers I tried didn't provide you enough information to do this (eg. if you had the path /user/User and you just did a naive find/replace that was more complicated than lowercasing, you'd accidentally change both when the route was /user/{string} so the first one shouldn't change). I also wanted typed route parameters to avoid the boilerplate of converting in my handlers every single time, and I wanted it to not have any ambiguous routes (eg. if I register /user/me and /user/{user string}, and the user creates a new account with the username "me" then should /user/me trigger the static route or the user page?). To fix all this I came up with the route syntax I've been using in these examples and made a muxer for it.
1. Wallpaper adhesive (https://github.com/jacobmischka/wallpaper-adhesive), an electron app I made ages ago when electron was still relatively new that creates spanned wallpapers for multimonitor setups based on your displays' resolutions. I use it every time I change my wallpapers, every month or so.
2. ics-merger (https://github.com/jacobmischka/ics-merger), a suite of tools including a webapp to merge separate calendar feeds together into a grouped feed, with possible subgroups. One can navigate through the subgroups, see event details, and subscribe to a merged feed, among other similar things. I made it for work, where it's used as the master departmental calendar feed. The webapp heavily relies on fullcalendar, but the added features aren't trivial.
3. Tea whistle (https://github.com/jacobmischka/tea-whistle), my second simple microcontroller project I made for my mother for her birthday because her teapot doesn't have a whistle so she kept accidentally boiling it over. It just polls the attached thermometer and beeps when the temperature is over boiling. She uses it every day and says she hasn't boiled it over once since!
4. inmytime.zone (https://github.com/jacobmischka/inmytime.zone), a simple webapp that allows you to create a URL that converts the time you give it into the local timezone of whoever is viewing it. It's effectively just a clone of https://everytimezone.com/ or one of the many other similar tools, but much less busy and without ads. I let the domain expire a few months ago, so it's not currently available, but I just renewed it so it should be again once the domain servers propagate. Edit: Seems to be back up for me now, at least.
5. Gym notebook (https://github.com/jacobmischka/gym_notebook), a flutter app I made when flutter was still quite new to track my workouts using firebase for storage. It's quite rough around the edges, fetches data from the network way more often than necessary, and needs a few bugfixes and could use a bit of work, but it's still good enough for me to use it 4-5 times per week.
the next tool i made for myself is a personal web link manager, i was unhappy with the way chrome lets add a bookmark which is not a very systemized way,so now my software lets me add my fav. web links. you just have to create a topic and add all the links related to that topic, i also added a search bar to help me find the links, and many small features are also added, since its a personal software its very efficient, it would be useful for those who use internet a lot and want to save their important links.
- edit -
Yes, shadowbanned again. Have a look at the comment history on this account and decide for yourself whether this is in any way defensible.
I'm done with HN.