Show HN for May 27, 2026

Introducing Posthorn, a self hosted email gateway. One docker container (or Go binary) between every self hosted app on your VPS and your transactional email provider. Set up Posthorn once, point your apps to it, done.

I was trying to deploy Ghost on a DigitalOcean droplet and found that DO and many different VPS services have started to block the default SMTP ports to try to combat the various types of abuse they get. To actually configure my app, I had to hack together a Postfix relay.

In another project, I had a static site which had a contact form, but my free Formspree account was occasionally hitting usage limits and I desperately wanted some of the anti-spam features they had gated behind their paid accounts so I put together a caddy module to catch HTTP POSTs and bounce them to my provider.

I kept bumping into these same email issues. Many of the services I wanted to host (Gitea, Mastodon, Umami, Comentario) ran into the same limitations. This felt like a really common issue that had no good solution.

Posthorn is what I built to solve this. It's a small Go binary (or 10 MB docker image) that sits between your self hosted apps and your transactional email provider of choice (shipping with support for Postmark, Resend, Mailgun, Amazon SES or an outbound SMTP relay). It also accepts POSTs from HTML forms to support static site needs while adding security layers such as honeypot fields, origin checks and IP rate limiting. There's also a JSON HTTP API that supports Bearer auth for backend scripts or cron jobs that just want a /send endpoint.

I now use this personally in multiple scenarios and I've spent a lot of time beating this up and testing against what I can validate. I'd love to hear how this might be useful for you, what breaks and any feedback you might have. It's open source under Apache 2.0 and I'd love contributions. I'm planning to support and grow this for the long haul.

Code: https://github.com/craigmccaskill/posthorn

Docs: https://posthorn.dev/

Longer write up: https://craigmccaskill.com/introducing-posthorn/

Previous HN discussion on the exact issue I'm trying to solve: https://news.ycombinator.com/item?id=43620318

I have a bad memory and can't memorize some important numbers, so I created this project.

I've always been concerned about being without my phone (getting robbed - which is common in Brazil - running out of battery, having it break, etc.), so I decided to create a page that sends SMS messages (LLM-summarized) and emails with more detailed information such as geolocation, IP address, and the full message.

It’s a simple page that allows sending one or more messages, with recipients being myself and other people - for example, in case I or they need help or need to communicate something important.

The source code is available at https://github.com/skhaz/dokku/tree/main/apps/help

Hi I'm Dan from Elodin, making an open source real-time capable flight software simulation.

For AI Grand Prix contestants, the wait for the Round 1 virtual qualifier simulation has been grueling.

If you’re competing, check out our simulation harness to tide you over, built to match the published competition constraints and message format. It runs against real Betaflight, which we learned requires at least 1000 sensor samples per second to run real-time correctly.

The competition warranted introducing a new feature to generate the camera sensor directly in the simulation loop. Typically people connect to Unreal or similar game engine to create a camera sensor, which works well but is very heavy. For the simple needs of this challenge, creating sample directly in the loop is very handy and easy to use. Happy to hear your feedback on this! While it's not fancy looking currently, it uses the Rust Bevy game engine, which should allow us to improve the visual fidelity quickly.

We all should easily be able to shift our implementation to the published competition sim once it lands. Hope you enjoy and good luck!

Hello HN,

I would like to share Filemat, a web-based file manager that I built because I wanted something with a simple setup and file permissions that work across the filesystem (as opposed to permissions only for a folder managed by the app).

It's self-hosted and open-source (currently in beta).

I'd be happy to hear your feedback

Repo: https://github.com/bingud/filemat

YO,

I’m Ryan, lead author. I’ve been contributing open source generative audio stuff for a while now, audio reactive Comfy nodes, extended ACEstep support in Comfy, etc.. I just opened-sourced a new audio project that I've been working on for a few months and I want to tell y'all about it.

WHAT IS IS DEMON: Diffusion Engine for Musical Orchestrated Noise

This is StreamDiffusion but with audio instead of images, and ACEStep 1.5 instead of Stable Diffusion. It’s responsive enough that you can play it like an instrument, and remix in near real-time.

I also distilled the ACEStep VAE: it’s faster at the expense of some quality.

I also trained something like 200 lora/dora for ACEStep 1.5 and 1.5XL: I will release these in batches of 5 or 10 or something

WHY IT IS Two reasons: 1) Making music is an inherently real-time activity 2) Why not bro

SOME RUNTIME CAPABILITIES -Real-time remixing of songs -Denoise, structure, timbre strength adjustment -Reference track swapping -Prompt blending, parameter scheduling with curves -LoRA hotswapping, runtime strength adjustment -Latent channel (research preview) -Feedback -Vocal stem cutting/pasting with melformer (s/o u/BuffMcBigHuge) -XL support (its less stable, working out VRAM pressure issues and whatnot) -Lyrics/vocals SOON -Spectral quality SOON -Other stuff

SOME LIMITATIONS -ACEStep (correctly) ‘begins’ and ‘ends’ the song. This system is optimized for remixing either an entire song, or continuously remixing a loop. The loop works fine, but this is not pure, continuous music. Autogression wins here. -Many others, for a more exhaustive list, please see the full writeup via the project page -Please let us know if you find any, I would love to try and address them if possible

LINKS My YouTube (DEMON tutorial): https://youtu.be/FBv1b5gmjcE Github: https://github.com/daydreamlive/DEMON Project page: https://daydreamlive.github.io/DEMON LoRA: https://civitai.com/models/2416425/acestep-loras DreamVAE: https://huggingface.co/daydreamlive/DreamVAE Try it w/o installing: https://music.daydream.live

I made a pixel pipeline explorer for the original Game Boy's Pixel Processing Unit (PPU). If you are implementing a Game Boy emulator or just interested in it then this might provide some help :)

Hodor is a tiny macOS app that launches saved AI prompts into any text field — from the screen edge, keyboard shortcut, or keyword such as ;git.

I work with different AI tools every day, and had prompts scattered across Raycast snippets, Apple Notes, and Notion — notes that kept getting longer and unmanageable. Raycast snippets are useful, but cumbersome to browse and edit. I wanted one local place to save and review them, and one click to paste them into whatever AI tool I'm using. The test I set was whether I could actually stop using Raycast snippets for this. I think I fulfilled my goal. Hodor has been my daily tool for 3 months now.

The app is 701 KB — SwiftUI + SwiftData, no web views. Zero network requests anywhere in the code: no analytics, no telemetry, no update checks. You can verify - search the source for URLSession, it's not in code.

Runs on macOS 15+, with native Liquid Glass on macOS 26+. Free and open source.

GitHub: https://github.com/woody-design/hodor

Let me know if you have any suggestions — I'd love to hear how you solved the scattered-prompts problem.

For the past 2 years, my girlfriend and I have been software engineers at CERN working for the ALICE and CMS experiments. A few months ago we decided to leave and focus full time on building our own products as we realised we'll never make the jump otherwise. Draw on a Map is the first one we've shipped and it already has nearly 300 users.

Draw on a Map doesn't need an account for you to draw and share, and the map stays in the URL fragment (not sent to the server) when not logged in. You can open, draw, share in a matter of 30 seconds.

The app is built on top of Cloudflare and using the data from OpenStreetMap. We wanted something lean that doesn't require a big time investment to learn how to use.

Would highly appreciate any feedback!

Hi HN, I built VAEN (an open source CLI) because I kept running into a boring problem with AI coding-agent workflows: the setup becomes useful, but then it is hard to move.

A good, useful agentic harness consists of more than just instructions: skills, mcp servers and more. There should be a better way to share those than just .MD files, and that is why I created VAEN.

What works: create a yaml, run the CLI commands as per the repo, and get a .agent file that you can share and extract. Think of how awesome it could be if anyone could use a very useful agentic harness, and share it with one CLI command.

I built an open-source tool for learning anything using AI:

- Type what you want to learn - It creates a full interactive course for you

Move from beginner to mastery of any subject, even complex things like Quantum Physics

It has three formats:

- Explanation: bite-sized lessons that you swipe like TikTok/Instagram - Practice: solve problems in real-world situations - Quiz: test your knowledge in Duolingo-like lessons - Language courses have a different format covering vocabulary, reading, and listening skills

It's more hands-on than reading a long textbook or watching a video

Plus, it uses everyday language, so it's easier to connect complex concepts to your reality. I built the tool I wish I had when I was in school/uni

Of course, I'm biased but I've been using it for the past few weeks and I'm truly loving it. I can't imagine myself going back to learning through traditional ways

If you have some spare time, please give me your brutal feedback. No need to be soft in the comments: give me real, honest feedback. I’m sure current approach/version has tons of issues. I want to turn this into the best learning tool in the world and, eventually the go-to place for learning and career development, so any feedback is really helpful

GitHub repo: https://github.com/zoonk/zoonk

Hi HN,

I have about 2000+ bookmarks that I will never read. Probably you do too. I keep collecting new stuff to read, the list grows longer each day, but I barely get around to reading them, and the problem, as I realised, is more to do with the analysis paralysis on what to read. Sort of like how we spend so much time figuring out what movie to watch on Netflix.

So I made a simple Chrome extension: it picks one bookmark at random, drops you on the page, and gives you two buttons on a floating toolbar - Stumble (next random one) or Done (mark read and move to the next random one). That's it. It takes away the burden of decision altogether, and it's sort of fun to engage with because of the variability (and novelty) of what it loads next, while still being within the universe of things I've been wanting to get to. Also, I've added daily goal and streaks to keep me motivated to get through the list and turn it into a daily habit.

You can simply Right-click -> Add to Stumbleback for new saves, otherwise it just reads your existing Chrome bookmarks, or you can paste URLs as well, no separate database.

It's free. Would love feedback from anyone who's tried to get through their reading list of things and failed.

Hi All,

I felt like I was re-inventing the wheel by bolting similar channel architectures onto different Go structs repeatedly so I decided to extract some common types into into one library so that they would be easier to re-use:

  - oneshot
  - spsc
  - spmc
  - mpsc
  - mpmc
  - broadcast
  - watch

The types are inspired by Rust channels so if you're coming from Rust they should feel familiar. So far I'm really enjoying using them but it'd be great to get some external feedback if you have time!

https://github.com/amorey/gochan

Andres

Hi there,

I'm building a map tool - Tasmap. It combines the functions of articles, maps, and design. The goal is let people can easily build beautiful maps without design/engineering effort. There are many demo and use-cases on landing page, take a look and give it a try :)

- Eddie Hsu

I recently went on a long walk (to get newborn twins to nap) and ended up having a long discussion with ChatGPT in voice mode; asking it to explain how the Enigma machine worked and clarifying all the errors in my current understanding.

I ended up going right back to basics and then subsequently spent ages failing to understand how it was cracked. Anyway, I built this in an attempt to recreate that arc for people (like me) who find Enigma intimidating: 13 stages, ~15 minutes, ending in a sandbox machine and the "no letter encrypts to itself" flaw that doomed it.

Built with React + SVG + GSAP. Rotor wirings and stepping are historically accurate; an Advanced toggle exposes Ringstellung and M4. Feedback very welcome, especially on stages that drag or lose you.

An index fund of every company linked to Jeffrey Epstein has returned 2,563% since his conviction.

The S&P did 609%.

This is Axion, a guitar rig that runs entirely in the browser. I originally built it as a tool to help me while writing and producing an album, then eventually decided to turn it into a proper product. Would love to hear what people think.

Hi HN. STAX IDE is a macOS app where every terminal session, code editor, and file browser is a movable, resizable window on a single zoomable canvas. `Cmd+wheel` to zoom out and see the whole workspace; zoom in to one window and use it like a normal app.

I built it because I was running 8-10 Claude Code / Codex shells in parallel and tabbed terminal apps kept losing my place. I wanted to see every shell at once and drag them around like Post-its. And have my browsers and notes in there too.

Implementation choices that might be interesting:

• AppKit, not SwiftUI. I needed manual frame control during drag/zoom to avoid AppKit's display-cycle re-entrancy guard, and got it more reliably out of straight NSView land.

• SwiftTerm (Miguel de Icaza's emulator) for VT100 + real PTYs (fork + openpty). One `LocalProcessTerminalView` per tab. OSC 7 → cwd → tab title.

• `NSScrollView.magnification` for canvas zoom. Cmd+wheel events are coalesced to one mag-update per display frame and the resync broadcast is hopped to the next runloop tick. Earlier versions used to SIGTRAP inside `_postWindowNeedsLayoutUnlessPostingDisabled` because the broadcast was re-entering AppKit's layout pass under aggressive zooming.

• Intentionally human-grep-able. No SQLite, no proprietary format.

• NSPasteboard drag-and-drop. Finder→canvas drops a folder and spawns a new stack with that folder as cwd. File-panel→terminal drag inserts the absolute path at the cursor.

•`NSTextStorageDelegate.processEditing` for syntax highlighting in the editor panels. 22 languages, extension auto-detect, plus a Sublime-style status-bar language picker.

* macOS only.

Install:

    brew install --cask vbario/staxide/staxide

Site / DMG releases: https://staxide.com

Built solo, used daily, lots of rough edges. Bug reports and corrections both welcome.

I've been building Legato, a realtime audio graph framework for Rust. The idea is to sit somewhere between PureData/MaxMSP (graph-based, visual routing) and something like JUCE.

The core of it is a minimal runtime and DSL for graph definitions. There are no loops, branching or evaluations. It's purely for wiring nodes together. If you want real logic, you write a custom node in Rust, register it, and drop it into the graph.

This way, you can easily extend the framework with Rust, as opposed to having to learn SuperCollider or CSound.

In addition to adding nodes in Rust, you can compose macros/templates/patches(still unsure which name I like best) of nodes, and then call them like regular nodes:

patch voice(attack = 200.0) { in freq gate audio { sine: mod, sine: carrier, adsr { attack: $attack, ... } }

    freq >> mod.freq
    mod >> carrier.freq
    gate >> adsr.gate
    carrier >> adsr[1]

    { adsr }

}

Patches inline into the same flat allocation, so spawning voice * 5 for polyphony is not too hard on memory layout.

There are better examples in the linked repository. They also "compose", so you can use patch a in patch b, etc.

The primary target right now is hardware — the idea is that you could build a VST, software synth, or groovebox and deploy it on embedded Linux (Raspberry Pi, etc.) using the NixOS images I'm working on (although not necessary).

Currently I am using CPAL to handle cross platform audio APIs.

I'm currently working on a few grooveboxes I will open source, likely in the tracker space.

The license is AGPLv3 with an additional permissions file that waives source disclosure for most creative projects (VSTs, synths, grooveboxes) without DAW/AI functionality.

Still early (no 0.1.0 yet), but the DSL parser, graph executor, midi tools, and a handful of nodes are working, and for myself I am already finding it productive.

Looking for feedback, contributors, and people looking to dogfood the project.

I will likely start posting some video demos on various platforms in the upcoming weeks, as it's at a point where it's actually quite fun to perform with.

Repo: https://github.com/legato-dsp/legato Docs: https://legato.gg