Ask HN: What are you working on? (July 2025)

Our target platform is a 40 grams tinywhoop so it’s safe to fly everywhere and makes almost no noise :). A Roomba for mosquitoes!

The main plus compared to traditional systems is that a drone can cover an enormous surface in a short time compared to static systems or man-portable insecticide spraying. Our goal is to be competitive with ITNs against Malaria.

Some links :

https://hackaday.com/2025/03/25/supercon-2024-killing-mosqui...

https://manifund.org/projects/build-anti-mosqu

Intro video: https://www.youtube.com/watch?v=X_eKc6c5tDw

I'm 97% certain this is because the faster code leads to more page thrashing in the mmap-based index readers. I'm gonna have to implement my own buffer pool and manage my reads directly like that vexatious paper[1] said all along.

[1] https://db.cs.cmu.edu/papers/2022/cidr2022-p13-crotty.pdf

Since we added MCP and the use of structured output to "spill" multiple return values into adjecent cells, it is the quickest way I know of to monitor competitors blogs everyday before my 09:00 meeting. And also the quickest way I know of to test new AI models. I have a sheet with SimpleQA, MMLUPro, or GPQA Diamond and testing a new model is a matter of adding a new column. The whole idea is to enable normal people (like, non-techies) to automate manual, repetitive tasks with AI like programmers routinely do.

https://github.com/getcellm/cellm

I've been working on an open source LLM proxy that handles the boring stuff. Small SDK, call OpenAI or Anthropic from your frontend, proxy manages secrets/auth/limits/logs.

As far as I know, this is the first way to add LLM features without any backend code at all. Like what Stripe does for payments, Auth0 for auth, Firebase for databases.

It's TypeScript/Node.js with JWT auth with short-lived tokens (SDK auto-handles refresh) and rate limiting. Very limited features right now but we're actively adding more.

Currently adding bring-your-own-auth (Auth0, Clerk, Firebase, Supabase) to lock down the API even more.

GitHub: https://github.com/Airbolt-AI/airbolt

So far I've cataloged about 1500 advertisements out of the ~100,000 in my possession. Of which that is probably only 0.1% of all the major material out there. It's going to take a long time! I'm going at a rate of about 10,000/year. I'm going to have to speed this up :) But I've gotten the process to catalog a full magazine down from a week to a few hours.

I'm thinking of ways to support the archive. I am doing original art from the ads I may sell, or sell really nice copies of rare ads.

It's designed for sync, so rather than fetching you can hook it up to a sync engine (any!) to keep your front end in sync with your backend. It's built on Tanstack Query, making the sync engine optional, and a great path for incremental adoption.

The query engine uses a typescript implementation of differential dataflow to enable incremental computation of the live queries - they are very fast to update. This gives you sub ms fine grade reactivity of complex queries (think sql like joins, group by etc).

Having a lot of fun building it!

https://tanstack.com/db/latest https://github.com/TanStack/db

The guiding principles are to create a fun, positive, safe space for kids and families to socialize and interact as well as empower kids to explore and understand technology as a creative tool and not just as something to consume content.

This month I'm improving CI/CD for e2e testing across Windows, macOS, Linux and Android. Also adding support for unlocking password-protected PDFs and Word docs and improving OCR. OCR runs in the background and leverages native OS OCR where available and a pure LSTM Rust implementation elsewhere. Generally improving the word processor and looking for speedups. Adding a cross-platform spellchecker leveraging native where possible, too.

Play with it online: https://tritium.legal/preview

Download for free: https://tritium.legal/download

Since WGU just started doing masters degrees in CS, I decided it would be a way to kill large amounts of time while getting at least a little out of it, so I registered for it.

I've been a professional software person for like fourteen years, so I was able to knock it out extremely quickly due to WGU's competency based stuff, so now I finally am able to put "MS" after my name.

Recently I also made a font for it! https://untested.sonnet.io/notes/433-how-to-make-a-font-that...

I'm also thinking about organising the usage patters, because over the past few years I've collected a few interesting groups: mental health focussed users, script writers, neurospicy folks, bloggers, squirrel enthusiasts. I'm thinking about this here: https://untested.sonnet.io/notes/how-people-use-enso/

The app is designed for older adults who enjoy reminiscing but struggle to organize their thoughts into a coherent narrative. The goal is to preserve their hard-won insights and pass them down—to family members who may be too busy to ask the right questions now, and to future generations who would otherwise never hear these stories.

I have a working prototype that allows me to test the interview flow, and I’ll soon be sharing it with friends and family for initial feedback. I’m now looking for a designer to collaborate on the next phase.

Design will be a critical part of this app. The way stories are visually presented will be central to the user experience and will likely determine the app’s success. If you’re a designer interested in this kind of work, I’d love to hear from you. Given the text-heavy nature of the app, experience with typography and content-focused design will be especially valuable.

New: a deep research mode that, on demand, crawls thousands of product pages and uses visual LLMs to read label photos (ingredients, counts, square footage) when the text is messy. First run takes ~60–90s, then it’s cached.

A good torture test: 20×25×1 MERV 13 home air filters—listings mix single/4/6/12-packs and vague claims (“3-month,” “allergen defense”), which wreck per-unit comparisons. I’d love feedback on misses (coupons/Subscribe & Save/region), categories to add, and to collaborate with a grocery-list app, budgeting tool, or anyone in the frugal/deals space. chris@popgot.com

https://airdefense.dev/

It's a motivated video introduction to Elliptic curve arithmetic where in 10 minutes we write (in the C language) a legal bitcoin wallet bruteforcer.

Video edit: https://leetarxiv.substack.com/p/a-programmers-introduction-... Bruteforce bitcoin puzzle wallet in C : https://leetarxiv.substack.com/p/hacking-dormant-bitcoin-wal...

The C/C++ library can be easily embedded in host applications or plugins. It even runs on embedded devices, such as the ESP32. In addition, the project contains a Pure Data external and SuperCollider extension. There is also a third-party Max/MSP external: https://github.com/ddgg-el/aoo-for-max

For more background information, check out this article: https://www.soundingfuture.com/en/article/aoo-low-latency-pe... https://aoo.iem.sh/

The project is still in beta stage, but I hope to make a final release this summer.

Can be described as Astroneer-like setting, Teardown voxel physics, in a Valheim-like online multiplayer survival game.

Game isn't really announced yet but I've shown some videos of the tech: https://x.com/Alientrap/status/1909316208563732866 (On Youtube: https://www.youtube.com/watch?v=ZWISaUmvit4 ) https://x.com/Alientrap/status/1918024969939808654

It does this by building a profile out of a small number of selected past articles, and we make the profile and how it produces recs from the profile transparent and editable. Especially after feedback on HN (https://news.ycombinator.com/item?id=44454305), Im trying to get to grips with why people seem to care as much about seeing how their recommendations work as they do about the actual quality of recommendations themselves.

I'm increasingly convinced its due to how many opaque LLM-powered everything and black-box recommendation algorithms there are. People want personal content systems (they are useful for sure!), but theres a lack of ones where they stay in control of what 'personal' actually looks like.

I have a couple of family members and friends who are looking to buy businesses (separately), and it's been much more time-consuming than you'd expect just to browse through listings to determine if they're relevant to you or not.

The platforms seem to mostly follow the same format as real estate listings (as the brokers seemingly rely on the same software/data formats), with one big blob of freeform text that contains the various information that you'd ideally just be reading at a glance.

Add to the fact that there are over 15 "business for sale" type platforms in Australia where they have a minimum of 1,000 listings and at least 10 platforms with between 100-1,000 listings, you can easily burn hours looking through them individually.

I'm currently covering 12 of the top 15 (ranked by number of listings they contain) platforms and I just tinker away once or twice a month, adding support for new platforms.

I should probably release it and get some feedback at some point, but I suffer a bit from "it needs more polish before I let people other than my family and friends use it"

It is possible to run Playwright inside a Chrome extension, however, it requires the Chrome DevTools Protocol (CDP) to automate a browser which really hurts the user experience, is very slow, and opens security vulnerabilities. Chrome extension APIs can accomplish maybe ~85% of the same functionality as CDP or Webdriver BiDi -- it isn't complete because of security features which shouldn't be bypassed anyhow. For example, instead of calling a function in a content script with 'script.callFunction' with Webdriver BiDi in Playwright, a function is called with chrome.scripting.executeScript(). It will be 2 or 3 more weeks before I post a PoC.

This is following my work using VSCode's core libraries in a Chrome extension exactly as they are used in an Electron app to drive VSCode and Cursor. The important part is VSCode's IPC / RPC which allows all the execution contexts and remote runtimes to communicate with each other. [0] This solves many problems I have had in the past automating browsers with a Chrome extension.

[0] https://github.com/adam-s/doomberg-terminal

Trying to document and map as much of the publicly accessible stained glass as possible. The goal being the next time you visit a new city or town, you'll know where all the beautiful stained glass is to go see. Just recently added support for countries outside of North America. No exciting tech (vanilla HTML/CSS/JS). But excited for folks to check it out!

Encryption uses Fernet (symmetric), and all decryption happens only at point of access. There's no data retention after viewing or expiration. Optional analytics give visibility without compromising identity. Users can get notified when their shared links was accessed by the recipient, and they can set passwords for enhanced security. Limitations include email-based signups and no end-to-end encryption (yet).

You can check it out at = https://www.closedlinks.com/

You can read the white paper here - https://www.closedlinks.com/white-paper/

This is a wheel I see people reinventing all the time, often for use in SaaS applications. The implementations are often underwhelming: function support is limited, documentation is sparse to non-existent and errors are typically only communicated at runtime -- if at all. Formula editors usually lack autocomplete, making them frustrating to use.

I've spent years solving all these problems (with a statically-typed language), and I'd love for others to benefit from the work. I have extracted the formula engine from our app compiler, so the library is nearly complete. The runtime part (evaluating formulas) has been rewritten in TypeScript. Next, I'll build a service around it to validate, compile and evaluate formulas -- which should be fun.

I'm planning to do a Show HN once I have a preview up and running.

- The idea: https://carlnewton.github.io/posts/location-based-social-net...

- A build update and plan: https://carlnewton.github.io/posts/building-habitat/

- The repository: https://github.com/carlnewton/habitat

- The project board: https://github.com/users/carlnewton/projects/2

It records my voice, transcribes it locally using faster-whisper, and copies the transcription to my clipboard. Check the demo linked in the GitHub repo to see how it works.

I use it especially with Claude Code to provide detailed context for the outcome I want to achieve. I ramble for 5 minutes, and then paste the transcription to Claude Code, instead of having to type all my thoughts all the time.

The workflow is like this:

  $ hns # start recording
  <talk>
  <Enter> # clipboard now holds the text

Had a fun week fixing up the application so it’s 100x faster on 5 different axes, and it’s starting to feel really well polished. Also started to move from reagent to preact/signals in a long slow migration hopefully to hsx.

I also moved the critical algorithm logic into an independent Clojure file that is compiled (and tested) with cherry-cljs — I’m hoping to expand this to ClojErl and jank so I can have isomorphic Clojure code running on the browser, BEAM server, and native swift app :D

It’s getting really close to done, I’m using it now to study 18 different languages, including some really minor ones like Maltese, Welsh, and Cantonese (not sure if Cantonese is really a minor language, but definitely low learner resourced) and it’s easy, slick, and surprisingly effective!

Reception so far has been positive. It's nice to be done with a long project, though this one will never exactly be done--I need to make sure there is a new puzzle for each day, though I have several months' worth prepared in advance.

I've started designing my next game, but it's probably a couple of years out. I just need something for that part of my brain to occasionally chew on.

[1] https://www.omiword.com/

[2] https://news.ycombinator.com/item?id=43654350

[3] https://news.ycombinator.com/item?id=44075038

Basically, nattokinase is an enzyme made by natto (Japanese fermented soybeans). It’s been show clinically to help against blood clots. Unfortunately, the clinical dose is 5x the quantity in a serving of natto.

That’s too much natto to eat! So I’m working to genetically engineer a normal, typical natto strain to just over express that one enzyme, so 1 serving == 1 clinically relevant dose

My last was genetically engineering yeast to produce grape aroma, then baking bread. Was great fun feeding people it. I want to eventually throw GMO dinner parties in SF, but only with GMOs I’ve created with my own hands

Lets you hide 1000s of images, pdfs, videos, secrets, keys into a single portable innocent file like "Vacation_Summer_2024.mp4".

Supports deployments of your own apps as well as 15k+ other packages (postgres, airbyte, dagster, etc) via helm charts.

https://github.com/czhu12/canine https://canine.sh

Reason? Got sick of paying for the massive markups on PaaS but missed the simplicity and convenience.

After working on and using many MCP servers, I hit couple of issues multiple times:

* Do I configure 2 MCP servers of same type for 2 different API Keys or do I manually update configurations all the time? (e.g. production and development environments)

* when I have too many tools enabled, I noticed that either I am hitting context limit too quickly or LLM is hallucinating when choosing a right tool

* Some MCP servers expose a lot of tools, I want to disable some of them forever, instead of doing configuration per AI assistant (first for Claude, then Cursor and so on)

* Most MCP servers are hosted by third parties, as a privacy conscious person, I do not want to share my credentials with third parties.

And I am building Aiko - AI tools marketplace: https://getaiko.app

NOTE: Gmail and Calendar apps are currently under CASA Tier 2 security assessment, hence not published to production. But you can see demo usage here: https://www.youtube.com/watch?v=ZgEy6Y1kfn4

You select columns and then just drill down to create further joins. Change the SQL text and it updates the view.

I'm a CS undergrad would love feedback.

It was also important to me to provide a non-hyped, balanced view (hence the name), including pointing people to realistic assessments of the effectiveness of these tools and highlighting the risks and concerns.

I get "time blind" when I'm fixated on something like work, programming, reading, research, etc. While it can be a good thing, it also means I forget to eat, don't take breaks, miss meetings, or just spend way too long doing one thing and end up wondering where the day went. Typical notifications don't seem to snap me out of it either.

The app creates a thin, always visible line at the bottom of my screen that shrinks inwards as time passes, at the end of the allotted time the screen will blur preventing me from doing whatever I was doing and snapping me out of my hyperfocus state. I can choose how long the timer runs for and how long the screen blurs for. Tonight I added a loop feature so I can use it like a pomodoro timer with enforced breaks.

It's a simple menu bar app for MacOS and could be better, but it does what I want it to do. I've been using it for the past week and found it really helpful.

I haven't used Swift before so it was a good learning experience too.

It's the same principle as a Time Timer (timetimer.com) which I used previously but I find my app works better as the screen blur actually prevents me from just continuing whatever I'm doing, and the bar is always in my line of sight.

The core of the project is a “Spilled Coffee Principle,” which basically says that if I spill coffee on my laptop, I should be back up in an afternoon. Every configuration change is codified into scripts, not a one‑off terminal command. Setup scripts create directories, handle symlinks, document dependencies and generally remove the “Brent the bottleneck hero” problem.

Beyond that, the repo lives inside a P.P.V system (Pillars, Pipelines, Vaults) where dotfiles are one of the pillars. This structure separates foundational configs from automation pipelines and secure vaults. It forces me to think at the system level: how do all of my tools fit together, where do secrets live, and how can I onboard a new machine (or person) with a single `git clone && ./setup.sh`?

What’s really interesting is the mindset shift this has caused. I’ve been experimenting with what I call the OSE (“Outside and Slightly Elevated”) principle: moving from micro‑level, line‑by‑line coding to a macro‑level role where you orchestrate AI agents. At the micro level you’re navigating files in an editor and debugging sequentially; at the macro level you’re using tmux + git worktrees + AI coding assistants to run multiple tasks in parallel. Instead of `1 developer × 1 task = linear productivity`, you get `1 developer × N tasks × parallel execution`, which has obvious 100×–1000× potential. This OSE approach forces me to design workflows, delegate implementation to agents, and focus on the “why” and “what” instead of the “how”.

The result is that my dotfiles aren’t just about aliases anymore; they’re a platform that bootstraps AI‑assisted development, enforces good practices, and keeps me thinking about the bigger picture rather than getting lost tweaking my prompt or editor colours. I’d love to hear how others are approaching the macro vs. micro balance in their own setups.

  GET /hello
    |> jq: `{ world: ":)"}`

  pipeline getPage = 
    |> jq: `{ sqlParams: [.params.id | tostring] }`
    |> pg: `SELECT * FROM pages WHERE id = $1`
    |> jq: `{ team: .data.rows[0] }`
  
  GET /page/:id
    |> pipeline: getPage

https://williamcotton.com/articles/introducing-web-pipe

I would love feedback!

So I built Stoodious as a study guide platform that intends to give you the material and get out of your way, as opposed to the engagement-driving gamification of others. One of the killer features is being able to drill practice questions related to the specific study section you're working on - e.g. 20-30 questions about water rights, encumbrances or calculating GRM. Frequently my wife found herself studying vocab for a section but having to skim through a 100-question practice test to find related questions.

I extended the material to all 50 states' basic real estate licensing exam and am looking to add even more "professional exam" material.

Last month I decided to take a subscription of my own for Claude Code to use in my personal time mostly for practice and educational purposes.

So the past few weekends and the occasional week night I've been vibe-coding a game for iOS/MacOS using Swift and SpriteKit.

I have some experience with Swift previously but not at work, so it's extremely experimental for me. However it's been going pretty well. Most of the hang-ups are Xcode configuration issues.

It's interesting to poke Claude a bit and discover what it's actually decent at and awful at.

Gameplay mechanics-wise it's been able to implement things as requested generally without problems.

UI elements like menu screens and such it has been almost completely unable to do no matter what prompt I give to it.

It's safe to say I would never call the codebase professional quality. However, the base game has been implemented well enough to play without bugs and I've been solidly impressed.

It uses whisper.cpp under the hood and should be accelerated on most devices using the Vulkan backend