2025년 8월 3일의 Show HN

Hey HN,

I'm a software engineer with a passion for playing guitar. (https://ivanhsu.co)

In the software industry, we use clever plain-text syntaxes like Markdown and Mermaid to handle complex layouts. This lets us focus on the content itself and quickly produce beautifully formatted documents.

Isn't sheet music and chord charts just another form of documentation in the world of music?

That's why I created Cord Land https://cord.land/landing ! It's a website where you can quickly generate lead sheets and draw chord charts using plain text.

Even better, it can automatically transpose songs! Just write in one key, and it can be instantly converted it to any of the other 11 keys you want.

I've implemented a new syntax called Corduroy, an extension of ChordPro syntax specifically designed for guitarists. Besides showing chord names above lyrics, you can also customize chord charts. For example, `%x32o1o%` will automatically draw a C major chord in the first position!

Feel free to try it out here: https://cord.land/landing#playground For more usage details, please refer to: https://cord.land/tutorial

The name "Cord Land" comes from "Cord" and "Chord" being homophones, representing chords.

Let's keep our passion for playing guitar alive, even after work!

Ivan Hsu

Hi HN, I’ve always struggled with impulse buying—that late-night Amazon scroll or the "deal" that's too good to pass up. I realized I was trading long-term goals for short-term dopamine hits. The core problem is the frictionlessness of modern e-commerce.

To fight back, I built Nope It. It’s not just another budgeting app. It's a PWA designed to interrupt the impulse loop at the critical moment.

How it works is based on a few key psychological principles:

Forced Pause (The Cooldown): Inspired by Daniel Kahneman's "Thinking, Fast and Slow," the app introduces a mandatory 24-hour cooldown on any logged impulse. This shifts you from impulsive "System 1" thinking to deliberate "System 2" thinking.

Cost Re-framing (Work Hours Psychology): It immediately translates the item's price into a more tangible metric: This $80 gadget costs you 4 hours of your work. This technique, known as "opportunity cost visualization," makes the trade-off much more real.

Goal Redirection: Instead of just saying "no," the app encourages you to immediately contribute the saved amount to a pre-defined Wishlist Goal (e.g., "Vacation Fund," "Down Payment"). This replaces the lost dopamine from buying with the positive feeling of making progress.

The Tech:

It's built as an enterprise-grade behavioral platform, but the front-end is a simple, fast Progressive Web Application (PWA) so there's nothing to install. It's accessible on any device, instantly.

I wanted to turn a personal weakness into a strength and thought others might find it useful too. I'm here to answer any questions about the psychology, the tech, or the journey.

Would love to get your feedback!

Check it out here: https://www.nopeit.app

This is software for my headless, PC based oscilloscope, which is controlled entirely via commands similar to the Vim text editor. I built this because I liked the idea of headless oscilloscopes; I always have my laptop around when I’m working on electronics anyway, and it’s very convenient to save images of captured waveforms. However, I found the software for off the shelf models to be annoying and cumbersome to work with. In my experience, this holds true both when opening the software and connecting to an attached oscilloscope, and when adjusting the scope settings using menus and buttons. I have also built my own oscilloscope hardware for use with Voltpeek. The specs are nothing to write home about (7.5MHz BW, 62.5MS/s), but they should be adequate for some basic debugging and measurement tasks.

Hey HN,

I wanted to share something I've been working on for the past couple of months, which may be interesting to developers interacting with distributed architectures (e.g., microservices).

I'm a backend developer, and in my 9-5 job last year, we started building a distributed app - by that, I mean two or more services communicating via some sort of messaging system, like Kafka. This was my first foray into distributed systems. Having been exposed to structured concurrency by Nathan J. Smith's beautiful article on the subject (https://vorpus.org/blog/notes-on-structured-concurrency-or-g...), I started noticing the similarities between the challenges of this message-based communication, and that of concurrent programming, and GOTO-based programming before that - actions at a distance, non-trivial tracing of failures, synchronization issues, etc. I started suspecting that if the symptoms were similar, maybe the root cause, and therefore the solution, could be as well.

This led me to design something I'm calling "structured cooperation", which is basically what you get when you apply the rules of structured concurrency to distributed systems. As it turns out, doing that has some pretty powerful consequences, including:

- Pretty much eliminates race conditions caused by eventual consistency

- Allows you to recover something resembling distributed exceptions - stack traces and the equivalent of stack unwinding, but across service boundaries

- Makes it much easier to reason about the system as a whole

I put together three articles that explain:

1) what structured cooperation is (https://developer.porn/posts/introducing-structured-cooperat...),

2) one way you could implement it (https://developer.porn/posts/implementing-structured-coopera...), and

3) why it works (https://developer.porn/posts/framing-structured-cooperation/).

I also put together a heavily documented POC implementation in Kotlin, called Scoop (linked in the title). I guess you could call it an orchestration library, similar to e.g. Temporal (https://temporal.io/), although I want to stress that it's just a POC, and not meant for production use.

I was hoping to bounce this idea off the community and see what people think. If it turns out to be a useful way of doing things, I'd try and drive the implementation of something similar in existing libraries (e.g. the aforementioned Temporal, Axon (https://www.axoniq.io/products/axon-framework), etc. - let me know if you know of others where this would make sense). As I mention in the articles, due to the heterogeneous nature of the technological landscape, I'm not sure it's a good idea to actually try to build a library, in the same way as it wouldn't make sense to do a "structured concurrency library", since there are many ways that "concurrency" is implemented. Rather, I tried to build something like a "reference implementation" that other people can use as a stepping stone to build their own implementations.

Above and beyond that, I think that this has educational value as well, and I did my best to make everything as understandable as possible. Some things I think are interesting:

- Implementation of distributed coroutines on top of Postgres

- Has both reactive and blocking implementation, so can be used as a learning resource for people new to reactive

- I documented various interesting issues that arise when you use Postgres as an MQ (see, in particular, https://github.com/gabrielshanahan/scoop/blob/09db323bf6c8a7... and https://github.com/gabrielshanahan/scoop/blob/09db323bf6c8a7...)

Let me know what you think.

Tired of long or unnecessary meetings? I built a cost tracker that will show you the cost of your meeting. Start it before a meeting and have it visible on the table and show everyone how costly it it, I guarantee you it will be a short an efficient meeting!

Hi HN,

We built Zomni because we were tired of sleep trackers that show data but don’t help you actually sleep better.

Zomni is a personal sleep coach powered by AI and rooted in CBT-I, the most effective treatment for insomnia. It doesn't just record your sleep; it gives you a daily plan and dynamic recommendations tailored to your real habits, rhythm, and mindset.

The problem: Most sleep apps show you charts like “6h 42min” or “sleep efficiency: 78%,” but leave you wondering: now what? They often make sleep worse by encouraging unrealistic goals and reinforcing bad patterns (like over-napping or obsessing about 8 hours).

What we built:

A fully conversational AI sleep coach (built on OpenAI)

Hyper-personalized advice based on your last 3 nights of sleep

A CBT-I–based sleep plan that updates automatically

No wearables, no stress — just real habit change.

We’d love feedback — from tech, behavior, or personal perspectives.

Thanks for reading, Zomni Team

Hey HN

I built https://www.namefast.me/ , a tiny tool that helps you find creative, brandable names for your SaaS or startup, instantly.

You just describe your idea in one sentence, and it returns a list of name ideas that are: • Short • Easy to pronounce • Mostly available as .com • Not just “GPT mashups” or generic name junk

⸻

Why I built it:

Every time I start a new side project, I lose hours stuck on naming. Tools like ChatGPT often give boring, inconsistent or unusable results. So I made something focused, minimal and fast — made for indie makers, not corporations.

⸻

How it works: • No signup • Enter your idea in plain English • You instantly get 8–15 curated name ideas • Refresh for more

⸻

Would love your feedback on: • Are the names actually helpful? • Would you want filters (like “funny”, “edgy”, “one-word”, etc.)? • Is this useful beyond first-time use?

Feel free to roast it or suggest improvements – open to any ideas

Thanks,

You can try it here : https://www.namefast.me/ — Viggo

I've been learning all about autostereograms (aka "Magic eye" illusions) recently and had a fun idea: If I can somehow get a depth image of my webcam, I can see myself in a "magic (eye) mirror" on my screen. It turns out that it's actually pretty feasible to get real-time depth estimates, at least on newer hardware and in browsers with WebGPU. To my delight, this worked pretty well, so I decided to polish it somewhat and share it here.

To be honest, all the heavy lifting is done by the depth-estimation model [1], otherwise this demo just wouldn't be possible.

I will warn you that viewing this may take some practice if you aren't already very well-versed in autostereogram viewing, and you will probably only want to run this on somewhat beefier laptop/desktop hardware, preferably in a Chromium browser.

For something less intense and mobile-friendly, I also made a sibling app that works with still images: https://namuol.github.io/magic-eye-anything

Both projects are open-source:

- https://github.com/namuol/magic-eye-mirror - https://github.com/namuol/magic-eye-anything

[1]: https://huggingface.co/spaces/Xenova/webgpu-realtime-depth-e...

Hi HN,

I've been working on a different kind of life assistant — one that helps in the real world, not just with voice commands or smart speakers.

Andre is a privacy-focused, location-aware assistant that does things like:

Remind you to take care of errands only when you're near a place to do them

Alert you about major events like flight cancellations, gridlocked traffic, or wildfires — and suggest nearby hotels or rentals

Adapt to your real routine, without tracking you or selling your data

It's early-stage, but I'm sharing it now to get feedback, connect with others building human-first tech, and possibly find collaborators.

The site at https://andreapp.org is still under construction, but it's live.

This project is dedicated to the person who gave me the courage to build again — even from a hospital bed. A small tribute, but a real one.

Thanks for reading, Bill

I've been experimenting with speed‑running UI builds. To test myself, I cloned Apple's AirTag landing page using React (Vite) and Tailwind CSS. The goal was pixel‑accuracy, based on a custom Figma layout inspired by Apple's design. I recorded the process as an eight‑minute speed‑run.

– GitHub: https://github.com/andreupifarre/apple-airtag – Video: https://youtu.be/cXrOBLCQqkY

I reproduced the layout using Tailwind's utility classes and a few custom components. I'm eager to hear feedback from fellow builders, what would you improve, or how would you approach this challenge?

The last Show HN I did got me a wide amount of attention for that project, and I'm incredibly grateful to everyone here who upvoted and commented. I realize, of course, that it's also the luck of the draw. I did my best to fix some of the issues pointed out in the comments. There are still a few more things I need to fix, which I'll get to soon!

In any case, I figured I might as well share another project I've worked on. This isn't as complex as LisaGUI, and it's perhaps not as Show HN-friendly in that there's not really much to tinker with, but it was hand-crafted with great care, and it's technically interactive.

This is a gallery website I created for my grandmom's artwork. I coded everything by hand from scratch. Like LisaGUI, the website's front-end is a single page with no frameworks. You will need JS enabled; there's a bit of code that retrieves images and string data about each painting.

On the back-end, I wrote a utility to modify the gallery database (which is just a JSON file and some directories holding images). The utility consists of a python3 script that runs a locally hosted server. This launches the default browser and opens up a GUI that lets you rearrange and edit the image file and strings for each entry in the database. I created a short video demo which showcases this; it can be watched here: https://yaros.ae/data/misc/loriegalleryeditordemo.mp4

This was made during the height of the pandemic. My grandmom was depressed about not being able to go out as much as she was used to. In the past I had discussed the idea of making a website for her, and at that moment it seemed like the perfect thing I could do to help cheer her up.

Why code this from scratch? First, at the time I couldn't find a website builder offering the exact kind of template I was looking for. I wanted something that had the look and feel of a white-cube art gallery with placards on the wall next to each painting. Second, sites offered by site builders tend to be quite bloated. I wanted the leanest, simplest site possible for my grandmom's work. Third? Well of course, to see if I could do it.

I also have a clone of this site hosting my own artwork (https://art.yaros.ae/). I originally planned on making this extensible and more user-friendly so anyone could use it as their portfolio, but I never got around to it. (Consequently, right now this isn't licensed for anyone else to use.) But at this point, for most people it would probably be easier and take far less time to just set up something on Squarespace or Wix or some other site builder. The average artist probably doesn't want to have to go through the hassle of manually hosting their own site anyway (or doing something silly like updating it through commits via GitHub!).