2025年11月5日 的 Show HN

Hi everyone,

For the past couple months I've been working on a website with two main features:

- https://book.sv - put in a list of books and get recommendations on what to read next from a model trained on over a billion reviews

- https://book.sv/intersect - put in a list of books and find the users on Goodreads who have read them all (if you don't want to be included in these results, you can opt-out here: https://book.sv/remove-my-data)

Technical info available here: https://book.sv/how-it-works

Note 1: If you only provide one or two books, the model doesn't have a lot to work with and may include a handful of somewhat unrelated popular books in the results. If you want recommendations based on just one book, click the "Similar" button next to the book after adding it to the input book list on the recommendations page.

Note 2: This is uncommon, but if you get an unexpected non-English titled book in the results, it is probably not a mistake and it very likely has an English edition. The "canonical" edition of a book I use for display is whatever one is the most popular, which is usually the English version, but this is not the case for all books, especially those by famous French or Russian authors.

I designed a relative piano-roll-based music notation. I used 12 colored arranged in a specific way to make visible the main effects and oppositions of Western tonal harmony. The tonic is always white, so a manual annotation/interpretation is required for each MIDI file.

All chords are flags of three to four colors. Minor mode is darker, major mode is lighter. Colors are arranged in thirds.

I sorted the pieces from simple complex harmony. I also wrote a bit of text to explain what you may see. There's also a corpus of structures: hyperlinks of tags that allow you to find similar patterns throughout my corpus of 2000+ popular pieces.

My method makes chord progressions memorizable and instantly visible in the scores. No preparation of Roman numeral analysis / chord symbols analysis is required. After a bit of training the chords will stare right in your eyes.

It's not synesthesia, it's a missing script for tonal music which makes harmonically identical things look the same (or similar).

I've also recorded lectures on my method in Russian (https://www.youtube.com/playlist?list=PLzQrZe3EemP5pVPYMwBJG...). I'm sorry I haven't yet found time to re-record in English.

I've also sketched a friendlier intro: https://vpavlenko.github.io/d/

Sorry, but this thing won't make any sense if you're color-blind.

It's open-source: https://github.com/vpavlenko/rawl

Earlier context: https://news.ycombinator.com/item?id=39165596

(Back then colors were less logical, and there was no corpus of 2000+ piece annotated yet)

Every once in a while, I hear developers complain about how working with ROS2 frustrates them, or students who find the barriers to understanding ROS2 too high. Undoubtedly, ROS2 was originally designed in the lab for the prototyping phase.

However, being widely adopted has turned its design into a messy blob that is not only "thick" - and not in a good way - but also too tangled. Therefore, I came up with the design for HORUS -Hybrid Optimized Robotics Unified System.

At first, I was just experimenting to see whether building a system that respects both the versions and dependencies of low-level packages like drivers, and high-level packages like ML/robotics algorithms would be that hard - unlike in ROS2. Surprisingly, with current modern technology, we can do a lot to make this vision come true. ROS2 users are always looking to avoid "reinventing the wheel" by trying to pick whatever exists in that tangled web and sticking it into their project. This workflow was good, at least in the old days. But now we have AI and modern frameworks/packages, yet developers are still struggling to make them work with ROS2.

My vision is to create a robotics framework that is "thick" as a whole (we can't avoid this - the tools, drivers, etc. make it impossible to be slim and fit everyone's needs), but modular by choice. I mean that developers, similar to ROS2, can still integrate their packages, but in a way that won't require opening at least 10 tabs. The design makes parts swappable - it's like building with Lego blocks, but with easy integration. You don't like this IPC communication mechanism? Swap it with a different IPC framework by editing 1 configuration line, and it won't break. You don't like these environment settings or how upgrading a single package breaks everything else? HORUS solves this.

HORUS aims to provide developers an interface where they can focus on writing algorithms and logic, not on setting up their environments and solving configuration issues. HORUS is designed to be both hybrid and unified. For example:

You can run horus run app.py driver.rs, and Python and Rust will communicate with each other seamlessly, as they all use shared memory for IPC. If a package is missing, the HORUS manager detects it and auto-installs a version that fits your current dependencies.

  By design, every HORUS project can be a virtual environment if you want it to be. You can use packages already installed on your machine and link them to your project, or install new ones exclusively in your project. This solves dependency hell and the "works on my machine" problem. We also have horus env freeze, which freezes your environment and provides you an ID that other developers can use with horus env restore  <ID> - similar to requirements.txt in Python.

  I know what you're thinking: don't we already have these features elsewhere? Why not just install them and integrate them into ROS2, like virtual environments or multiple compilers? That's where the unified part of HORUS comes in. Robotics as a whole should be cohesive for the most part. Continuously splitting things apart and then piecing them back together will just create another ROS2. Therefore, by original design, the ecosystem should easily adopt new components and make them native. HORUS has a registry - a database of sorts - that aims to grow by gaining more HORUS packages. This makes future development easier by making every HORUS project part of the ecosystem.

 Given all that, a modern robotics framework should have better performance, be high-level, easily integrate with AI/ML, and be user-friendly - even for students breaking into the field of robotics. HORUS is trying to achieve all of this, but without growth in the ecosystem, HORUS would be just another forgotten project.

 You can try it out with the documentation to see the vision and goals: https://docs.horus-registry.dev/

sudocode is a lightweight context management system for coding agents that lives in your repo. It helps organize the chaos of human-AI collaboration by capturing user intent as durable specs and tracking agent activity as issues, all version-controlled with Git. This "context-as-code" approach reduces agent amnesia and accelerates development on long-horizon tasks.

Answer the question "Before I die, I want to..." and post it to the wall.

I built this as part of a journaling app I’m working on as a side project. Personally I find life goals fascinating - they're the things we think will make us feel the happiest and the most fulfilled, yet often people think they won't achieve them.

I have tried to make it feel atmospheric with the goal of making you stop and think about your own life for a second.

Hi, I'm Andrew Trettel. I'm a scientist and researcher. I wrote Wosp to help me search local documents using Boolean and proximity operators.

Wosp is a command-line program that performs full-text search on text documents. Wosp stands for word-oriented search and print. It is designed for advanced searchers. It works differently than line-oriented search tools like grep, so it can search for matches spanning multiple lines. Wosp supports an expressive query language that contains both Boolean and proximity operators. It also supports nested queries, truncation, wildcard characters, and fuzzy searching.

The linked GitHub repository contains all of the code to try out the program. I also wrote a blog post (https://www.andrewtrettel.com/blog/wosp/) that discusses my motivations for creating Wosp in more detail, along with some additional technical discussion and diagrams.

If you give Wosp a try, I'd appreciate any comments or feedback you have about the experience.

It's a Mac desktop app that lets you iterate on storyboard, generate Sora videos, and edit them (stitching, trimming, transitions) to produce a long AI-generated video.

It's MIT license and BYOK.

We've found some fun use cases with Sora that are not brain-rot meme videos on the Sora app, for example: - Turning blog posts to video

- Making launch videos

- Making educational videos

- (currently experimenting) Marketing Ads

But we don't want to pay $200 for the max plan, so instead we built this to use our existing API credits. With this app, you have access to:

1. storyboard with a AI chat 2. watermark-free videos 3. sora-2-pro 4. basic editing with ffmpeg

Would love to hear some feedback. Hope you find it useful and fun too!

Download link (Apple Silicon): https://github.com/palmier-io/sixsevenstudio/releases/downlo...

It's time for a better Venmo/PayPal...

One that is globally accessible, makes you money and takes a cut of the profit instead of screwing you with fees and bad conversion rates

I made the iOS + web app and I'm handing it to you

Send USDC via email

Btwn Friends is an open-sourced PayPal/Venmo alternative that let's you send stablecoins to anyone's email without them being on the app, having a wallet or knowing about crypto.

Here's how it works

Every P2P payment app makes you create an account, save 12 words, link to a wallet app, KYC, transfer gas tokens...

It's intimidating and too much work

Your friend just wants their $20 back. They don't care about "decentralization"

Here you sign in with your email and a one time use password (OTP)

That's it.

You just logged into your wallet or created one. no wallet app, chrome extension, seed phrase, or crypto knowledge.

Your wallet is created automatically by Coinbase Developer Platfrom

To send money, you just need an email address.

Not a wallet address or an ENS name. Just an email. Enter: [email protected] → $25 USDC → Send

That's the entire flow.

The recipient gets an email: "John sent you $25" They click the link → Sign in with email → Funds appear.

They don't need to: - Set up a wallet - Have ETH for gas - Know what a blockchain is - Copy/paste addresses

If your friend is on the app → money goes straight to them

If they're not → money goes into an escrow

When they sign in with email & OTP, they prove they own that email.

Escrow releases funds automatically. They see their balance before the dashboard loads.

You can build onchain apps without forcing users to "learn crypto"

Between Friends is built on Base (Eth L2) using a basic escrow smart contract and is powered by Coinbase Developer Platfrom's Embedded Wallets (smart accounts) and Paymaster

I've done most of the job for you and left notes on what's left.

Coinbase Developer Platfrom's Embedded Wallets already give you ~%4 rewards on balance out the box

You can make more for yourself & your users leveraging onchain tools like @MorphoLabs, @MoonwellDeFi, @superformxyz...

→ Web app: https://btwnfriends.com

→ iOS testflight: https://testflight.apple.com/join/aZCPAjwZ

→ Repo: https://github.com/Must-be-Ash/btwnfriends

SasaSavic.ca recently launched a public cryptographic timestamping service designed to remain verifiable even in a post-quantum world.

The platform uses SasaSavic Quantum Shield™, a dual-signature protocol combining classical and post-quantum security.

Each submitted SHA-256 hash is: • Dual-signed with ECDSA P-256 and ML-DSA-65 (per NIST FIPS 204) • Anchored to the Bitcoin blockchain via OpenTimestamps • Recorded in a public, verifiable daily ledger

API (beta, no auth required): https://sasasavic.ca/beta-api/

Example curl request: curl -X POST https://sasasavic.ca/api/v1/beta/timestamp -H "Content-Type: application/json" -d '{"hash":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"}'

Verification and ledgers: https://sasasavic.ca/verify

https://sasasavic.ca/ledgers/

The goal is to make cryptographic proofs quantum-resistant and accessible, while preserving user privacy — only the hash ever leaves the client side.

Feedback from developers, auditors, and researchers on PQC integration and verification speed is welcome.

More details and documentation: https://sasasavic.ca/quantum-shield/

– The SasaSavic.ca Team

We’re building an open-source language layer on top of Go, designed specifically for COBOL-style workloads: Native decimal arithmetic (COBOL-accurate) Record structures and copybook compatibility Batch jobs and transactional orchestration as first-class constructs Sequential / indexed file I/O baked into the runtime Compiles through Go for speed, concurrency, and cloud deployability Think of it as Kotlin for COBOL, or “COBOL on Go” familiar to mainframe engineers, powerful for modern developers.

Test Results so far: NIST COBOL-85 validation: 77.61% overall (305/393 tests) NC (Core COBOL): 97.89% (93/95) SM (Statements): 100% (13/13) RL (Relative I/O): 100% (26/26) IF (Intrinsic Functions): 100% (45/45) IC (CALL): 96% (24/25) Compliance tests: 100% passing Acceptance tests: 100% passing

Hi Hacker Friends,

I'm excited to share my new project, ImagineToVideo. My goal was to build an AI video generation tool that’s powerful enough for pros but simple enough for everyone.

We're focused on making video creation straightforward and support three main modes:

● Text-to-Video

● Image-to-Video

● Template-driven Video

To balance quality and cost, we've integrated a range of models. For high-end, cinematic results, we support top-tier models like VEO 3.1 and Sora 2.

At the same time, we know those models can be expensive. To keep it accessible and reliable for more casual or high-volume use, we also offer the Kling model, which provides a great balance of quality and affordability.

Our core focus is:

Simplicity: A clean UI with no steep learning curve.

Model Flexibility: Choose the right model for your specific need and budget.

Versatility: Built for everyone from solo creators and marketers to e-commerce owners.

This is a new launch, and I'd be genuinely grateful for any feedback, bug reports, or feature ideas from the HN community. Let me know what you think!

Title: Show HN: Notifikai — Set and get reminders through simple text messages

Body: Hey everyone,

I built Notifikai because I kept forgetting small daily tasks when I was away from my phone or offline. Most reminder apps need logins, notifications, or constant internet—so I made something simpler.

With Notifikai, you just send a text like:

“Remind me to take my vitamins at 9am tomorrow.”

Then at 9am, you’ll get a text that says:

“Take your vitamins.”

No app, no setup, no logins—just plain SMS. You can create one-time or recurring reminders, manage them by replying to messages, and it all works anywhere a text message does.

I’d love feedback on what features would make this even more useful (for example: group reminders, daily summaries, or integrations).

Try it out here → https://notifikai.com

Thanks, Luke

We been helping mid-market companies for the past 1.5 years and finally ready to share the internal platform publicly.

Yansu (严肃) is a AI coding platform that use spec + TDD to build complex software projects. It is more like a SOP than coding agent. We focus on understanding requirements and checking outcomes against those requirements while iterating the code based on the tests.

Yansu tries to learn as much tribal knowledge as possible. These are things you don’t write down in google doc or Notion. Yansu absorbs these knowledge by continuously talking to users and distilling learning from them.

It's as if a spec + TDD platform had a baby with character.ai.

Why care about requirements? B/c 80% of any software development is understanding requirements and what exactly we want to build. We also focus on outcomes, the only thing that matters. We deliver satisfying outcomes by simulating scenarios and generating tests based on those scenarios. Our agents take that tedious testing part of the code away from others.

We prioritize accuracy over latency/cost, using a mixture of agents (not limited to CC, codex, and etc) to get the job done. We then run through continuous-testing-generating pipelines until all things pass.

What does Yansu mean? “Serious” in Chinese. Just like my favorite artist, Rene Magritte, painting in his kitchen in a suit. I want to give my coding respect and care.

Our goal is to level people up from IC to tech leads, to work on the high leverage work of planning, validating, and educating.

We made a launch video to celebrate human work that builds on all of the creative minds before us. Shoutout to CinemaSings for making this happen.

Enjoy the video (linked in the tweet) and check out Yansu.

I had a hard time figuring out CAD software like Fusion, OnShape, etc., and decided to go about making my own CAD modeling software that I can "program" my models similar to how I think about them in my head.

I used Cursor to write like 95+% of this, giving it my YAML examples and making it implement the actual code to make those work.

Currently 100% self-hosted, and it is just a static HTML/CSS/JS, so it might just work without running npm at all.

Very few features working currently, basically just modeling a few primitive solids, and boolean operations.

Hi HN, I'm the author of Kumi, a declarative, statically-typed, array-oriented, compiled DSL for building calculation systems (think spreadsheets). It is implemented entirely in Ruby (3.1+) and statically checks everything, targets an array-first IR, and compiles down to Ruby/JS. I have been working on it for the past few months and I am curious what you think.

The linked demo covers finance scenarios, tax calculators, Conway's Game of Life (array ops), and a quick Monte Carlo walkthrough so you can see the zero-runtime codegen in practice. (The GOL rendering lives in the supporting React app; Kumi handles the grid math.)

The Original Problem:

The original idea for Kumi came from a complex IAM problem I faced at a previous job. Provisioning a single employee meant applying dozens of interdependent rules (based on role, location, etc.) for every target system. The problem was deeper: even the data abstractions were rule-based. For instance, 'roles' for one system might just be a specific interpretation of Active Directory groups and are mapped to another system by some function over its attributes.

This logic was also highly volatile; writing the rules down became a discovery process, and admins needed to change them live. This was all on top of the underlying challenge of synchronizing data between systems. My solution back then was to handle some of this logic in a component called "Blueprints" that interpreted declarative rules and exposed this logic to other workflows.

The Evolution:

That "Blueprints" component stuck in my mind. About a year later, I decided to tackle the problem more fundamentally with Kumi. My first attempts were brittle—first runtime lambdas, then a series of interpreters. I knew what an AST was, but had to discover concepts like compilers, IRs, and formal type/shape representation. Each iteration revealed deeper problems.

The core issue was my AST representation wasn't expressive enough, forcing me into unverifiable 'runtime magic'. I realized the solution was to iteratively build a more expressive intermediate representation (IR). This wasn't a single step: I spent two months building and throwing away ~5 different IRs, tens of thousands of lines of code. That painful process is what forced me to learn what it truly meant to compile, represent complex shapes, normalize the dataflow, and verify logic. This journey is what led to static type-checking as a necessary outcome, not just an initial goal.

This was coupled with the core challenge: business logic is often about complex, nested, and ragged data (arrays, order items, etc.). If the DSL couldn't natively handle loops over this data, it was pointless. This required an IR expressive enough for optimizations like inlining and loop fusion, which are notoriously hard to reason about with vectorized data.

You can try a web-based demo here: https://kumi-play-web.fly.dev/?example=monte-carlo-simulatio...

And the repo is here: https://github.com/amuta/kumi

Hey HN, I'm Dave one of the co-founders of Zeeda.

After scaling my last company (Voxpopme) from 0 to $10M ARR and hiring 100+ people, I lived through the worst part of hiring: posting a role on LinkedIn, getting 200+ applications, and drowning in resumes where 80% are completely unqualified.

So we built Zee - an AI that conducts actual 20-30 minute first-round interviews (not just screening) with every applicant, then gives you a shortlist of the 5-10% actually worth your time.

We're also solving stakeholder misalignment too before Zee interviews any applicants he talks to key stakeholders about the role to go beyond basic job descriptions.

Would love HN's feedback, especially from fellow founders who've felt this pain.

Personally, I hate having to edit slides in Google Slides or PowerPoint because everything can be moved! After every simple text edits, I have to change the position of every text element, and so on. Awesome functionality is missing from HTML and CSS: auto-aligning.

The idea of converting Markdown to slides is not new. There are lots of tools that do it well.

Unfortunately, libraries like Reveal.js or Marp are too geeky and developer-focused for something as simple as creating quick slides.

That's where Slidepicker.com comes in.

Compared to tools like Marp or Deckset, Slidepicker focuses on creating slides that look really good. It's not just about fast and easy creation, but also about achieving great readability of the result.

We’ve just released a new version of SlidePicker, a simple web app that converts Markdown files into presentation slides. It’s designed for developers, writers and tech speakers who prefer text-based workflows, but who also want slides that are clean, ready to share and attractive.

The editor runs entirely in the browser and supports live preview and also includes a 'presentation mode' for talks.

We would love to hear feedback from anyone who has used Markdown-based slide tools: what are you still missing, and what is your ideal workflow for creating slides from code or documents?

Built a terminal dashboard for my M2 Mac because I wanted something better than jumping between Activity Monitor, terminal commands, and random cleanup scripts.

What it does:

Real-time charts for CPU, memory, disk... Quick actions menu - one key to flush DNS, fix WiFi, kill processes... Clean up all the dev cache garbage in one place (npm, Homebrew, Xcode, Go, Yarn) System insights with performance scoring

Basically everything I was doing manually or with different tools, now in one TUI.

Written in Go, GPL-3.0.

https://github.com/caioricciuti/dev-cockpit

Install:

curl -fsSL https://raw.githubusercontent.com/caioricciuti/dev-cockpit/m... | bash

Would appreciate feedback on the UI and what other quick actions or monitoring would be useful.

Hey y’all!

About 7 years ago, I had this idea to write a JIT with an autogenerated backend for x86 based on the ISA specs. I sketched something out and then just kinda let it sit. I picked it up again a few weeks ago and made a complete-ish backend for both x86 and ARM64. It has no dependencies, the backends are completely autogenerated (by horrible, horrible JS scripts), and I built a small abstraciton layer for things like functions prologues etc.

It’s super duper early and will probably break on your machine, but it’s good enough to compile some cool examples (look at the examples directory: https://github.com/hellerve-pl-experiments/cj/tree/master/ex..., my personal favorite is the minimal language implementation: https://github.com/hellerve-pl-experiments/cj/blob/master/ex...).

It doesn’t have anything except basically a fancy JIT assembler with some helpers as of yet. No register allocator, a lot of ABI details will still have to be figured out manually (though of course feel free to add anything to the abstraction layer that’s generally useful and submit a PR!).

I honestly don’t know where I’m going with this next. I kind of stumbled into the project, and am not sure whether I’ll consider it as “exercise completed” or whether I should pursue it more. Time will tell.

Feedback, questions, and bug reports very welcome—especially on the codegen helpers, additional examples or cool things you come up with, or backend rough edges.

P.S.: I also wrote a small announcement blog post on it that you can find here (https://blog.veitheller.de/cj:_Making_a_minimal,_complete_JI...), but it honestly doesn’t add all that much interesting info that you can’t find in the repo.

This post about strange attractors isn't as cool as this recent one: https://news.ycombinator.com/item?id=45777810. My visualization runs with my programming language, which is interpreted by WASM code and uses JS and Canvas – without WebGL.

A simple but useful internal tool we made and proved to be useful for us. Hopefully it can help someone else as well.

Convert ONNX files to OpenVINO and/or TensorflowJS

I’ve been working on resonaX — an experiment to see if we can simulate real B2B customers using AI.

The idea: instead of sending surveys or running A/B tests, what if marketers could ask questions directly to an AI twin of their ideal customer — built from real data like LinkedIn profiles, CRM notes, and behavioral insights?

Each twin captures that customer’s role, pain points, buying triggers, and communication style. You can then ask:

“Would this headline make sense to you?”

“Why would you hesitate to book a demo?”

“What would make this offer more relevant?”

Under the hood:

LLMs + embedding models fine-tuned on buyer language

Real-world inputs (LinkedIn data, optional CSV uploads)

Lightweight feedback layer to validate responses

70+ beta testers are using it to test messaging and GTM ideas before launch.

Would love feedback from HN:

How might you improve the data ingestion layer? How can I simulate a focus group? How can i combine data to create a digital twin of a post like VP of Marketing (broad as some users are demanding not testing with just one profile but a combination of atleast 10)?

Any ideas to make the twin modeling more reliable over time?

Free beta: https://resonax.ai