Show HN for September 15, 2025

Hi HN, I'm Oskar, a solo indie Mac developer from Sweden. For those in the Mac community, you might know me from my other apps like Sensei and Trim Enabler.

For years, I've been frustrated by the lack of customisation of macOS. In particular the Lock Screen which supports animated wallpapers, but only ones provided by Apple. There's never been a way to add your own personal videos.

I decided to figure out how to solve this, and the result is Backdrop 2.0. Backdrop is my Live Wallpaper app for Mac, it can play video wallpapers on your desktop. And now it can play on your Lock Screen too.

The core technical challenge, as you can imagine, came from trying to do something that Apple otherwise does not allow. However, through extensive reverse engineering of the macOS wallpaper system, I figured out a way to provide Backdrop wallpapers to the system in a way that allows them to play on the lock screen, and even appear in a custom section in System Settings.

I'm here all day to answer any questions—especially about the reverse engineering process, the challenges of integrating with macOS, or the experience of being an indie Mac developer.

Would love to hear your thoughts and feedback.

TL;DR: dagger.js is a buildless, runtime-only micro-framework that plays nicely with native Web Components. It uses HTML-first directives (e.g. +click, +load) so you can ship a page by dropping a single <script> from a CDN—no bundlers, no compile step.

Why I built it Modern stacks are powerful but often heavy: bundlers, compile steps, framework DSLs, local CLIs. For internal tools, small apps, and edge/serverless deployments, I wanted something you can view-source, paste into a page, and ship.

What it is:

Runtime-only: no build or VDOM compile; hydrate behaviors directly on HTML. HTML directives: e.g. +click, lifecycle +load / +loaded / +unload / +unloaded. Zero APIs: dagger.js works in pure declarative mode, modules and directives provide everything you need to build your application. Web-Components-first: works alongside Custom Elements; keep concerns local. Distributed modules: load small, focused script modules via CDN. Progressive enhancement: the page renders without a build step.

Use cases:

Admin panels & dashboards that don’t warrant a full toolchain Embed widgets, docs-sites with interactive bits Edge/serverless apps where cold start and simplicity matter

Links

GitHub: https://github.com/dagger8224/dagger.js Docs/Guide: https://daggerjs.org Examples: https://codepen.io/dagger8224/pens

I’d love feedback on edge-cases, and where it breaks. Happy to answer tough questions here.

Hello everyone!

I’ve been building an Open Source Ecommerce framework for Angular called Daffodil. I think Daffodil is really cool because it allows you to connect to any arbitrary ecommerce platform. I’ve been hacking away at it slowly (for 7 years now) as I’ve had time and it's finally feeling “ready”. I would love feedback from anyone who’s spent any time in ecommerce (especially as a frontend developer).

For those who are not javascript ecosystem devs, here’s a demo of the concept: https://demo.daff.io/

For those who are familiar with Angular, you can just run the following from a new Angular app (use Angular 19, we’re working on support for Angular 20!) to get the exact same result as the demo above:

```typescript ng add @daffodil/commerce ```

I’m trying to solve two distinct challenges:

First, I absolutely hate having to learn a new ecommerce platform. We have drivers for printers, mice, keyboards, microphones, and many other physical widgets in the operating system, why not have them for ecommerce software? It’s not that I hate the existing platforms, their UIs or APIs, it's that every platform repeats the same concepts and I always have to learn some new fangled way of doing the same thing. I’ve long desired for these platforms to act more like operating systems on the Web than like custom built software. Ideally, I would like to call them through a standard interface and forget about their existence beyond that.

Second, I’d like to keep it simple to start. I’d like to (on day 1) not have to set up any additional software beyond the core frontend stack (essentially yarn/npm + Angular). All too often, I’m forced to set up docker-compose, Kubernetes, pay for a SaaS, wait for IT at the merchant to get me access, or run a VM somewhere just to build some UI for an ecommerce platform that a company uses. More often than not, I just want to start up a little local http server and start writing.

I currently have support for Magento/MageOS/Adobe Commerce, I have partial support for Shopify and I recently wrote a product driver for Medusa - https://github.com/graycoreio/daffodil/pull/3939.

Finally, if you’re thinking “this isn’t performant, can’t you just do all of this with GraphQl on the server”, you’re exactly correct! That’s where I’d like to get to eventually, but that’s a “yet another tool” barrier to “getting started” that I’d like to be able to allow developers to do without for as long as I can in the development cycle. I’m shooting to eventually ship the same “driver” code that we run in the browser in a GraphQl server once all is said and done with just another driver (albeit much simpler than all the others) that uses the native GraphQl format.

Any suggestions for drivers and platforms are welcome, though I can’t promise I will implement them. :)

An install script to create a strong and stable blend of Omarchy on top of CachyOS. You must install CachyOS first (please read the README file.)

Feedback and contributions welcome!

Pronounced Push-It....

I'm a lazy developer for the most part, so this is for people like me. Sometimes I just want my local code running in live remote containers quickly, without building images and syncing to cloud docker repos or setting up git workflows or any of the other draining ways to get your code running remotely.

With pooshit (and a simple config file), you can simply push your local dev files to a remote folder on a VM then automatically remove relevant running containers, then build and run an updated container with one command line call.

It works well with reverse proxies like nginx or caddy as you can specify the docker run arguments in the pooshit_config files.

https://github.com/marktolson/pooshit

Hi HN, Mahmoud here. I'm usually here for Python/FOSS reasons (boltons, glom, CalVer, ZeroVer), and that's still the case, but this time with a twist.

While I was on parental leave from Stripe a couple years back, I started helping my parents figure out their retirement. They're academics coming from overseas, so let's just say I'm a big part of the plan. We found ourselves quibbling over Zoom screenshares, multi-tabbed Google Sheets, and countless links to articles and blog posts. When we looked for professional advice, we found conflicting guidance and misaligned incentives.

I looked at the tools my friends and I use for big decisions and saw a huge gap. This isn't budgeting, nor is this investing. This is actual finance. Money management and decision making. Your options are usually:

1. Read a bunch of Bogleheads, Investopedia, Wikipedia, and Reddit. Then cobble together spreadsheets that we can only hope someone wants to look at (including future you). 2. Hire an expert, which involves a lot of trust, time, and money. You can't shop around too much and you also can't turn back the clock if your advisor burns you. They'll do the spreadsheeting (hopefully correctly) and ignorance is bliss.

I wanted something different. I wanted consumer FP&A, if there were such a thing. A collaborative sandbox for sharing financial context, with a bit of math, plus discussion threads with a context-ful chatbot, and an "explorable explanation" that my parents could use to see how different choices applied directly to them. Google Sheets just wasn't it.

Most importantly it had to solve the trust issue. Most bespoke financial apps are black boxes. I wanted something transparent, verifiable, and forkable. Like open-source software. So, I built FinFam on top of the most broadly-understood low-code platform of all time: the spreadsheet.

FinFam (https://finfam.app) is a platform where you can build and share interactive financial models, powered by XLSX and Google Sheets.

A few examples of questions I've worked through with my early access users:

- https://finfam.app/mahmoud/views/child-cost - How much will it cost you to raise a child from 0 to preschool in the Bay Area?

- https://finfam.app/mahmoud/views/big-tech-vs-startup - Should you take a big tech job or join a startup?

- https://finfam.app/mahmoud/views/ccp-oas-age - When should you start taking your Canadian retirement benefits?

Building each of these models has been super rewarding. The child cost one in particular was a great way to capstone my daughter's 3rd birthday. Yes, I really do have a dataset of her first 2800 diaper changes: https://finfam.app/blog/2025-08-26-baby-cost-view-case-study

Not only has it been more fulfilling and maintainable for me, I'm hopeful that it can open up a new audience of "sheetcoders". There are tons of folks with domain knowledge and spreadsheet know-how, but would never learn (or even vibecode) js/html/react. This way they can build something interactive, without losing the narrative guidance of a good blog post. Get subscribers, find new clients, maybe even get some MRR.

We've been running private alpha all summer. It's still got rough edges, but our small community is getting too much value out of it not to share. Would love to hear what you think. Thanks!

Hey HN, we’ve been experimenting a lot with MCP servers lately, and one of the most time-consuming challenges has been connecting MCP clients to remote MCP servers. To solve this, we built a library that generates them on the fly, enabling 1-click installation buttons and links for most clients out there.

Feel free to try out the generator and use it to improve the README of your remote MCP server with the generated markdown. You can even configure the library to return HTML instructions if someone accesses your remote MCP server via the web.

We made Ruminate over the past few weeks because we were frustrated with how hard it is to read complex text with LLMs - research papers, novels, long articles, etc.

We found ourselves copy-pasting the text/file into ChatGPT, having chats about different parts of the text in different tabs, and bummed we couldn't easily track the best insights from all those conversations in one place. We wanted one place where we could stay immersed in the text, dip into lengthy and generative rabbitholes when we wanted to (in an unobtrusive way), and have a 'work product' of your learning process (all your notes in one place). No more tab switching - one unified interface centered around the text itself.

With Ruminate, you can: 1) Upload PDFs, EPUBs, or web articles and read them in our custom reader (PDF upload done with https://github.com/datalab-to/marker; headless browser automation for web articles) 2) Highlight text to ask questions, get definitions, or discuss with an LLM (that has context on the whole document, the pages you've read, and will web search too) 3) Save notes, definitions, and annotations (and view them all later in their own tabs)

There are loads of ways to use an LLM to save you time and offload thinking/learning/cognition - we want this to be a tool that actually enables/empowers you to think more deeply and understand more.

Would love your feedback - on the product, the concept, or even your own experiences trying to learn from difficult material (or learn with LLMs broadly). Much appreciated.

Hi HN,

We just launched Blocks - an AI platform where anyone can build custom work apps and AI agents in minutes, no coding required.

We’re seeing a shift in how software is built and used. With AI, software isn’t just about tracking processes anymore - it can actively help people get work done.

The problem is that most teams still face 2 options: either buy off-the-shelf tools that never quite fit, or invest a lot of time and money into custom development. Neither works well.

Blocks is the third option. It’s an AI-native platform where teams can create apps and AI agents for their workflows just by describing what they need in plain language. The idea is simple: the person who feels the problem should be able to build the solution.

Each app in Blocks has three layers that work together:

UI: customizable interfaces for each role.

AI agents: automate tasks, integrate with systems, and take action.

Data: a built-in database

Having all three in one place means you don’t just get a custom tool - you get a system that automates, adapts, and improves over time. Teams can collaborate internally and externally, set roles and permissions, and connect to the systems they already use.

How it works: you describe what you need in plain language, and Ella (our AI builder) creates the app - UI, agents, and database. From there you can edit, extend, and integrate with tools like Google Sheets, Slack, HubSpot, monday.com and many more. Custom integrations are rolling out soon.

We’d love for you to check it out → https://blocks.diy

It’s still early days, so your feedback would be hugely valuable. We’d really appreciate feedback on:

How clear the build process feels to non-technical users.

Which integrations or agent use cases would be most useful.

Any rough edges you notice while testing.

Thanks for reading! we’re excited to hear your thoughts and happy to answer any questions.

- 307M registered domain names across 1570 domain zones total (.com, .net, .io, .ai, .sh, etc)

- 78M registered domain names across 312 ccTLD domain zones (.uk, .de, .io, .ai, .sh, etc)

- daily lists of newly registered domain names

- daily lists of expired domain names

- download all domain lists as one huge .zip file (1.2 Gb size)

I originally built this as a way to make it safer to give CLI coding agents more autonomy. I wrote about that particular use case here: https://ammar.io/blog/httpjail.

Any feedback is appreciated!

As a long time user of i3wm I've been frustrated by lack of bar plugins can display news headlines of my choosing, those that are available tend to use proprietary API's/feeds, hence I decided to create my own.

I3 News uses standard RSS/Atom links which get turned to rotating news headlines in the bar plugin of your choosing, app also incorporates support for scrollable snippets and handler for opening news links in browser. Currently supported i3/sway plugin list:

- i3blocks - waybar - polybar - i3status

Critique/suggestions are very welcome.

Built a tool that turns long-form content (articles, PDFs, YouTube videos) into 5 key points. Quick way to get the gist before diving deeper.

It’s not perfect, but surprisingly useful for research papers and long talks.

Tip: There’s a bookmarklet too. Hit it while browsing and boom, instant 5-point summary. Add it to your browser here: https://unrav.io

A WebRTC based toy blockchain network, hopefully useful for learning and demonstrations.

Hi HN,

I’m Elijah with Labspace Directory (https://www.labspacedirectory.com/), a new platform designed to help biotech companies find lab space.

Our site brings together available lab space across the Bay Area, serving startups through established life science companies. The platform is built to streamline the search process—saving time by centralizing listings, providing key details on availability, and helping companies connect directly with opportunities that fit their needs.

You can get started here: https://www.labspacedirectory.com/

We’re excited to share this with the broader Bay Area life science community and welcome any feedback as we continue to build and improve the platform.

ssh tuitype.app

A minimal daily typing challenge served over ssh in the terminal (using Go, Wish, and BubbleTea)

I created a SaaS that lets anyone create funny public service announcements for any situation or message. Chose from a predefined set of voices and there is an option to enhance your message using AI to make it sound better. Enjoy!

Hi Hacker News, I'm the creator of Helios, and I'm excited (and a bit nervous) to share it with you all. The "Why": Like many of you, I've been fascinated by the power of modern AI models, but frustrated by the high cost and centralization of GPU resources. I started wondering if we could apply the old-school distributed computing model (like SETI@home or Folding@home) to the modern AI stack. The goal was to build a network where anyone could contribute their idle compute power and, in return, get access to a powerful, multi-modal AI. The "What": Helios is an open-source platform to build that network. It consists of two main parts: an orchestrator server that manages a job queue and the workers, and a client-side worker that anyone can install on Windows or Linux. Users run the worker, contribute resources, and this forms a global, decentralized supercomputer capable of handling text, image, and audio tasks. The "How" (Tech Details): Architecture: It’s a classic Orchestrator-Worker model, written entirely in Python. The Orchestrator (orchestrator.py) is the brain, handling job distribution, worker registration, and a simple web UI. The Worker (worker.py) is the muscle that users run on their machines. Proof-of-Contribution (No Crypto!): This is the core access mechanism. To prevent spam and freeloading, you can only submit jobs to the network if you are an active, contributing worker with a good reputation. It's not based on tokens or blockchain; it's a simple, fair system based on participation. Dynamic Experts: Workers don't come pre-loaded with every model. The Orchestrator assigns AI models (e.g., a specific translation model, an image captioning model) to workers dynamically based on the current job queue. These models are pulled directly from the Hugging Face Hub, keeping the worker client lightweight. Multi-Modality: It's designed to route different job types (text, audio, image) to workers that have the appropriate models and resources available. This is very much an experimental, v1.0 project. I know there are huge challenges, especially around security (sandboxing tasks is a major next step), but I wanted to get a working prototype out there to see if the idea resonates with the community. I'd love to get your feedback on the architecture, the concept of Proof-of-Contribution, and any suggestions you might have. GitHub Repo (Code is here): https://github.com/fnoracr/helios-distributed-ai Project Page (Demo & Docs): https://huggingface.co/spaces/fnoracr/Helios_Distributed_AI-... Installers (.exe/.tar.gz): https://github.com/fnoracr/helios-distributed-ai/releases/ta... Thanks for checking it out!

Hey HN,

My co-author and I just published a paper on arXiv that formalises a framework we've been using successfully in probabilistic logic for many years. We decided it was time to properly lay out its foundations for classical propositional logic.

We cast propositional logic into a formal algebra where logical formulas are represented by sparse matrices. State Algebra isn't an algorithm in itself, but rather a language for manipulating Boolean functions. It provides a new set of tools that lets you express and reformulate existing optimization heuristics (like those from modern SAT solvers) and design completely new ones. State Algebra is trading the strict canonicity of ROBDDs for greater representational flexibility.

For those interested in abstract-algebraic logic, we build a self-contained formalism from the ground up. The core building block is an object we call a "t-object," which forms the basis of the algebra. It provides a different way to look at the structure of logical problems.

The algebra naturally extends to handle real-valued coefficients, which turns it into a tool for probabilistic logic and Weighted Model Counting.

The paper is a bit of a deep dive into the maths, but we'd love to hear your thoughts. We'll be in the comments to answer any questions. Critiques are very welcome!

Link: https://arxiv.org/abs/2509.10326

Hey!

I saw this post a few days ago on HN [1] about the new Nano Banana model and decided to play with it. It's incredible (Mostly for editing IMHO)! The thing is, Google AI Studio is great for chat... for images, the UI is not ideal.

So I decided to make my own thing: an infinite canvas for AI image exploration. :)

Right now it only supports Nano Banana, but the plan is to include OpenAI, Replicate, and fal.ai this week!

Would love to hear any feedback. Feel free to propose changes as well!

Github: https://github.com/za01br/koubou

[1] https://news.ycombinator.com/item?id=45215869

Hi guys,

I built Downtube , a fast and lightweight command-line tool to download YouTube videos or audio (MP4/MP3). It supports playlists, smart quality detection, and bundles ffmpeg — so no external dependencies are needed.

It works on Windows, macOS, and Linux, and is written in Node.js.

Would love any feedback or suggestions!