Ask HN: What problem are you close to solving and how can we help?

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • Scout APM - Less time debugging, more time building
  • OPS - Build and Run Open Source Unikernels
  • SonarLint - Deliver Cleaner and Safer Code - Right in Your IDE of Choice!
  • mtpng

    A parallelized PNG encoder in Rust

    Are you required to use PNG or could you save the files in an alternative lossless format [1]? If you're stuck with PNG, mtpng [2] mentioned earlier seems to be significantly faster with multithreading (>40% reduction in encoding times). If you're publishing for web, cwebp might also be a possibility with -mt (multithreading) and -q 25 (lower compression and larger filesize but faster) flags.

    [1] https://blender.stackexchange.com/questions/148231/what-imag...

    [2] https://github.com/brion/mtpng

  • Etar Calendar

    Android open source calendar

    I'm using Nextcloud to host my calendar. On my work Mac, I connect to it using Fantastical. On my personal Ubuntu machine I use GNOME Calendar, and on Android I use https://github.com/Etar-Group/Etar-Calendar

    Everything is seamless for me, though admittedly I'm not a super heavy calendar user.

    I plan to do a write up on my whole Google-free setup, but I haven't done it yet, unfortunately.

  • Scout APM

    Less time debugging, more time building. Scout APM allows you to find and fix performance issues with no hassle. Now with error monitoring and external services monitoring, Scout is a developer's best friend when it comes to application development.

  • ZeroTier

    A Smart Ethernet Switch for Earth

    Apart from some smaller projects building on top of WireGuard, there's Tailscale [1]. One of the founders is Brad Fitzpatrick who worked on the Go team at Google before and built memcached and perkeep in the past.

    Outside of the WireGuard ecosystem there's ZeroTier [2] which has been around for a while and they're working on a new version; and Nebula [3] from Slack, which is likely to be maintained as long as Slack uses it.

    There might be others, but with tinc these four are the ones I've seen referred to most often.

    [1] https://tailscale.com

    [2] https://www.zerotier.com

    [3] https://github.com/slackhq/nebula

  • Nebula

    A scalable overlay networking tool with a focus on performance, simplicity and security

    Apart from some smaller projects building on top of WireGuard, there's Tailscale [1]. One of the founders is Brad Fitzpatrick who worked on the Go team at Google before and built memcached and perkeep in the past.

    Outside of the WireGuard ecosystem there's ZeroTier [2] which has been around for a while and they're working on a new version; and Nebula [3] from Slack, which is likely to be maintained as long as Slack uses it.

    There might be others, but with tinc these four are the ones I've seen referred to most often.

    [1] https://tailscale.com

    [2] https://www.zerotier.com

    [3] https://github.com/slackhq/nebula

  • tailscale

    The easiest, most secure way to use WireGuard and 2FA.

    Apart from some smaller projects building on top of WireGuard, there's Tailscale [1]. One of the founders is Brad Fitzpatrick who worked on the Go team at Google before and built memcached and perkeep in the past.

    Outside of the WireGuard ecosystem there's ZeroTier [2] which has been around for a while and they're working on a new version; and Nebula [3] from Slack, which is likely to be maintained as long as Slack uses it.

    There might be others, but with tinc these four are the ones I've seen referred to most often.

    [1] https://tailscale.com

    [2] https://www.zerotier.com

    [3] https://github.com/slackhq/nebula

  • bert-for-inference

    A small repo showing how to easily use BERT (or other transformers) for inference

    Super vague answer:

    Put the questions in some semantic embedding space. Now you’ll have a vector representing each question. Then for each question, you can sort all the questions by how far the Euclidean distance is between their vectors. Or use some clustering algorithm like k means to find clusters.

    By Googling I found this to tutorial to put sentences in an embedding space: https://github.com/BramVanroy/bert-for-inference/blob/master...

    I did not read this and am not endorsing it, but it looks like it’s doing the right thing.

  • map-generation

  • OPS

    OPS - Build and Run Open Source Unikernels. Quickly and easily build and deploy open source unikernels in tens of seconds. Deploy in any language to any cloud.

  • single-spa

    The router for easy microfrontends

    Have you tried SingleSPA? I’ve used it in the past to get React apps inside an old AngularJS app to replace parts of it over time and it worked pretty well. Docs say it works with Vue as well but I don’t have any direct experience with Vue at all far less for this kind of task so I’m not really sure it will work but it is worth looking at https://single-spa.js.org/

  • mu

    Soul of a tiny new machine. More thorough tests → More comprehensible and rewrite-friendly software → More resilient society. (by akkartik)

    Short version: I'm close to figuring out how to encourage more prototyping of software by making tests super easy to write during the prototyping process, and so de-risking rewrites. But one problem I've been stymied by is how to represent expectations of screens when they contain graphics.

    Long version: My Mu project (https://github.com/akkartik/mu) is building a computing stack up from machine code. The goal is partly to figure out why people don't do real prototyping more often. We all know we should throw the first one away (https://wiki.c2.com/?PlanToThrowOneAway), but we rarely do so. The hypothesis is that we'd be better about throwing the first one away if rewriting was less risky. By the time the prototyping phase ends, a prototype often tacitly encodes lots of information that is risky to rewrite.

    To falsify this hypothesis, I want to make it super easy to turn any manual run into a reproducible automated test. If all the tacit knowledge had tests (stuff you naturally did as you built features), rewriting would become a non-risky activity, even if it still requires some effort.Turning manual tests into automated ones requires carefully tracking dependencies and outlawing side-effects. For example, in Mu functions that modify the screen always take a screen object. That way I can start out with a manual test on the real screen, and easily swap in a fake screen to automate the test. Hence my problem:

    How do you represent screens in a test?

    Currently I represent screens as 2D arrays of characters. That is doable a lot of the time, but complicates many scenarios:

    * Text mode character attributes. If I want to check the foreground or background color, I currently use primitives like check-screen-in-bg which ignores spaces in a 2D array, but checks that non-spaces match the given background attribute. In practice this leads frequently to tests that first check the character content on a screen and then perform more passes to check colors and other attributes.

    * Non-text. Checking pixels scales poorly, either line at a time or pixel at a time. A good test should seem self-evident based on the name, but drawing ASCII art where each character is a pixel results in really long lines or stanzas. So far I maintain separate buffers for text vs pixels, so that at least text continues to test easily.

    * Proportional fonts. Treating the screen as a grid of characters works only when each character is the same width. If widths differ I end up having to go back to treating characters as collections of pixels. So Mu currently doesn't support arbitrary proportional fonts.

    * Unicode. Mu currently uses a single font, GNU Unifont (http://unifoundry.com/unifont/index.html). Unifont is mostly fixed-width, but lots of graphemes (e.g. Chinese, Japanese, Korean, Indian) require double-width to render. That takes us back to the problems of proportional fonts. Currently I permit just variable width in multiples of some underlying grid resolution, but it feels hacky.

    Can people think of solutions to any of these bullets in a text-based language? Or a more powerful non-text representation?

  • innernet

    A private network system that uses WireGuard under the hood.

    Similar to Tailscale is the Innernet project, which has similar goals but is fully open source (also built on Wireguard). I've heard that set-up is a bit more painful, but for those who are interested in FOSS or self-hosting, it might be worth looking into.

    [1] https://github.com/tonarino/innernet

  • ChessPositionRanking

    Software suite for ranking chess positions and accurately estimating the number of legal chess positions

    I'm trying to get a more accurate estimate of the number of legal chess positions at https://github.com/tromp/ChessPositionRanking

  • Kirby

    Kirby's core application folder

    Any headless CMS would work well my `mkws`, my idea is to build a smaller, simpler Wordpress that also comes with a tiny webserver, 0 config, no database, content stored as plain text files, just download and run. https://getkirby.com/ is closer in concept, but without the PHP dependency.

  • informed-citizen

    a system to keep citizens informed as they graze the airwaves

    I worked on a similar idea last year. What I did was take urls to content, scrape the content, and pipe it through a machine learning a evaluator to apply various labels and warnings to content. Lastly, add some nice embeddable UI to surface the report.

    I got it to a decent state, but didn’t know how to propagate it or inject it into social communities. I wanted people to be able to tag it on Facebook, and it would reply with an informational card with the analysis and summary.

    https://github.com/dino-dna/informed-citizen

  • kaldi-gstreamer-server

    Real-time full-duplex speech recognition server, based on the Kaldi toolkit and the GStreamer framwork.

  • Kaldi Speech Recognition Toolkit

    kaldi-asr/kaldi is the official location of the Kaldi project.

    I worked on this for a couple years during a previous startup attempt. I designed a custom STT model via Kaldi [0] and hosted it using a modified version of this server [1]. I deployed it to a 4GB EC2 instance with configurable docker layers (one for core utils, one for speech utils, one for the model) so we could spin up as many servers as we needed for each language.

    I would recommend the WebRTC or Gstreamer approach, but I wouldn't recommend trying to build your own model. It's really hard. Google's Cloud API [2] works well across lots of accents and the price is honestly about the same as running your own server. If you want to host your own STT (for privacy or whatever), I'd recommend using Coqui [3] (from the guys that ran Mozilla's OpenSpeech program). Note that this will likely be much, much worse on accents than Google's model.

    [0]: https://kaldi-asr.org/

  • testing-samples

    A collection of samples demonstrating different frameworks and techniques for automated testing

    https://github.com/android/testing-samples/blob/main/ui/espr...

    https://github.com/android/testing-samples

    Alternatively, Squish [3] is a very polished and more elegant commercial testing tool that lets you record test-cases using a GUI tool and convert them into (ideally modularized) methods that verify object properties or compare (masked) screenshots of the GUI:

    [3] https://www.froglogic.com/squish/features/

    Demo video: https://youtu.be/ElH-3MVHPRw?t=864

    They abstract away a lot of the functionality using the Gherkin [4] domain-specific language so that tests are easier to read at a high level (but you can still dig down into the underlying programmatic implementation).

    [4] https://cucumber.io/docs/guides/overview/

    This is probably too much complexity for your use-case, but may provide some ideas or inspiration for what is possible.

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts