What are you working on? Do you have any new ideas you're thinking about?

My roommate and I are still working on Tornyol, our mosquito killing drone! It uses ultrasonic sonar to detect mosquitoes, and missile control theory to ram into mosquitoes and grind them in its propellers.

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

Working on fabric construction blocks (like Lego of clothing), that you can use to build clothing and accessories completely by hand without any tools or machines.

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

Optimizing the Marginalia Search index code. The new code is at least twice as fast in benchmarks, but I can't run it in production because it turns out when you do it's four times as slow as what came before it for the queries that are the simplest and fastest to the point where queries exceed their timeout values by a lot.

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

I'm continuing the work on Cellm, an Excel extension that let's you call LLMs in cell formulas like =PROMPT(A1, "Rate the sentiment of the customer feedback as positive, neutral, or negative"), and then drag the formula down to apply the same prompt to thousands of rows. I built it after my girlfriend had to manually classify 7,500 research papers. Cellm automates that kind of repetitive work.

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'm finishing Flatcal https://flatcal.com a service that merges icalendar streams from various sources into one. It's weird that we can create multiple calendars to better organize scheduling and then to share availability we have to send each one as a separate link. It helps with more than that but sharing multiple calendars as one is the main goal atm.

I kept finding myself having to write mini backends for LLM features in apps, if for no other reason than to keep API keys out of client code. Even with Vercel's AI SDK, you still need a (potentially serverless) backend to securely handle the API calls.

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

I'm digitally cataloging all US vintage print advertisements I can get my hands on (https://adretro.com). The backend is built on MySQL and Lucee and the full page ads published with Notion and Super.so. I'm using OpenAI vision to extract entity data from the images.

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.

Tanstack DB - a new client side store for web apps, with transactions, optimistic state, and live queries spanning multiple collections.

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

I am working on a site that allows kids to chat and play online with other kids. To connect, kids must have their parents sign up and connect with the parents of their friends. Kids can chat with their parents and family as well as other kids in their network. Messages can be monitored by parents. There are also other activities like a bot workshop where simple llm bots can be "programmed" by creating system prompts (kids create video game helper bots, ice cream shop bots, adventure/dungeons and dragons style bots, etc). There is a sticker book (cartoon image search), and a quiz creator. Many other things are planned!

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.

Working on Tritium, the legal IDE in Rust (https://tritium.legal/)

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

I have been unemployed for the last few months, and there's only so much TV and YouTube I can watch without going utterly insane between interviews,

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.

After 10 years in defense tech, watching missile attacks in Ukraine and the Middle East made it clear how little most people really get about air defense. So I'm building this simulator which drops you into the operator’s seat. You can test out different scenarios and build an air defense network against various types of threats (stats from real world). Also have Ukraine, Israel-Iran scenarios. The new version is a lot more optimized, thanks in part to feedback from you all in HN. Currently I am working on a new featureset with missions, where the user is given a budget and geographical area to defend by placing different air defense assets; after which the system attacks it with various missiles and UAVs. Useful for just learning, exercises, playing through scenarios to defend critical infrastructure etc.

https://airdefense.dev/

I’m building Popgot (https://popgot.com): compare unit prices (per oz/sheet/lb) across Costco, Walmart, Target, and Amazon. We normalize fuzzy sizes (“family,” “mega,” multipacks) so you see the actually cheapest option for staples.

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

I'm editing my 3B1B summer of math exposition video: Elliptic curves for programmers

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...

Continuing to work on https://www.hackernews.coffee/ to rerank the HN frontpage based on my interests, not just what's trending.

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.

Have you ever wanted to write your life story but found it too overwhelming? I’m developing an app that acts as your personal interviewer, guiding you through your memories and helping you share them with your loved ones.

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.

Among other things, I'm working on AOO, a cross-platform low-latency peer-to-peer audio streaming and messaging library: https://github.com/spacechild1/aoo

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.

Because of a HN post(https://news.ycombinator.com/item?id=44421776), I've got a ton of feedback for Ensō: my writing app for flow/stream of consciousness writing. So, I'm wrapping up the release and adding good support for non-Latin, esp. RTL languages (Arabic, Persian, Hebrew) + pinyin and Japanese input methods.

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/

A multiplayer survival game based around voxel physics.

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

Been working on https://www.stainedglassatlas.com.

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!

I've been working on a "businesses for sale" aggregation/search engine that sources data from all of the major "business for sale" type platforms in Australia and de-duplicates listings, extracts data like revenue/profit/etc, and normalises it all for quick browsing.

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"

I'm copying the Puppeteer / Playwright client API to run in a Chrome extension using the native Chrome extension APIs.

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

I'm building ClosedLinks, a tool for sharing files and/or messages anonymously through one-time access links with no traceable sender. Most digital tools assume persistence; ClosedLinks is built for ephemerality and unlinkability. Each link is single-use, redirects on access, and stores encrypted content only temporarily. Recipients never see the original URL, enabling plausible deniability. Think: whistleblowers.

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/

I'm still working on Habitat. It's a free and open source, self-hosted platform for communities to discover and discuss their local area. The plan is for it to be federated, but that's a while off yet.

- 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

I'm working on an engine for Excel-like formulas, which will be available both as a library and as a service (which I've mentioned on HN a few times before). I originally started work on the engine back in 2008, when our app builder needed it.

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.

Building a local CLI tool, hns [1], for speech-to-text in terminal in 5 keystrokes.

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

Less than a week ago I officially launched a game I've been working on for years, Omiword[1], my second word game so far. It was discussed here on HN previously while it was in open beta[2], and again when Stripe shut down my account without explanation[3].

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

https://github.com/srv1n/kurpod

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

Still working on https://phrasing.app - an app for polyglots to learn over 120 languages in the most effective manner and a beautiful UI. Just finished a onboarding flow, now updating the search and create experience to fall more in line with actual usage from users, then hopefully prepping for a more public launch :)

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!

I've just published https://nohypeai.dev to share what I've learned about the state of LLM agents for software development and help people who are just catching up orient themselves.

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 built https://www.stoodious.app for my wife while she was studying for her California Real Estate Broker's Exam. She was frustrated with the price gouging on text books, or being the "state-of-the-art" study platforms being video only, having no/poor mobile UX or just feeling outright dated.

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.

I'm making a personal app to help me visualise time passing.

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.

I'm working on a Heroku / Render / Flyio alternative thats free, open source, built on top of Kubernetes.

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.

I am working on easiest way to manage all your MCP configurations and credentials. Additionally, I have added couple of interesting MCP servers, like converting any OpenAPI v3 spec to MCP server (including support of authentication): https://x.com/getaikoapp/status/1945278307496235482

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

I've been working on an new approach to working with SQL: https://5QL.site

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.

I'm finishing up a "book tour" (mostly podcasts) for my recently released book on how the country of Estonia modernized so quickly post re-independence from the Soviet Union and became a leader in e-government services and a top EU startup hub (Skype, Bolt, Wise, etc.). I'd love if people checked it out and gave feedback as it's my first big published work and the culmination of quite a few years of research and writing. https://www.rebootinganation.com/ or https://global.oup.com/academic/product/rebooting-a-nation-9...

Lately I’ve been heads‑down on a complete rethink of my dotfiles setup. It’s not just a `.vimrc` collection – the goal is to treat the dev environment like any other project: reproducible from scratch, automated, and designed to scale as AI becomes a bigger part of daily work.

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.

I've been working on Red Candle, a Ruby gem that runs LLMs (Llama, Mistral, Gemma, Phi) directly in your Ruby process through Rust bindings (based on the candle crate from Hugging Face). No Python, no servers - just FFI with Metal/CUDA acceleration.

It's been useful for adding AI features to Rails apps without the complexity of managing separate services. Would love feedback from anyone working with LLMs in Ruby.

GitHub: https://github.com/assaydepot/red-candle

Im investigating creating a nattokinase overexpression strain for fun. This is my second home-brewed food GMO!

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

A web app DSL that looks like:

  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!

We're supposed to use AI at work, which has been very 50/50 for me as expected.

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.

Been working on https://handy.computer. It's similar to SuperWhisper and others, but is open source and cross platform

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

Playing with motion amplification to see if we can predict heart/respiratory rate of my newborn. I shot a few 4k videos of him sleeping as test data and working through some algorithms from published papers.

On parental leave with my third. We are on month 4 so I have (a bit more) free time in the late evenings after we put the older ones to bed.

Working on a complex AI system that will eventually allow AI overseer subagents to create complex workflows internally on the fly for multi step reasoning capabilities. Its a vey complex system but easiest way I can describe it as a metacognitive framework for self organizing workflows depending on context and dynamic adjustment capabilities depending on environmental signals. lots of cool little systems that will do all types of fun stuff like feed logprobs to various Ai subagents to give extra bias signals or have the llms understand their own confidence in answering this or that query. Anyways I could write a whole decertation on all the various goodies in it. But currently at the moment starting small and working on developing automated hyperparameter reasoning evaluation system. its important to know the most affective hyperparameters per model and no better way to converge on those numbers then an automated system. After that using dspy or my own home brwe system to do same on converging for "best" system prompts for various tasks. And then setting up the various mcp servers that give these abilities to whatever llm uses them. Lots of work, but learning a lot in the process plus I love RND. I see potential in modern day systems for recursive self improvement just have to set up the system around the capability. thats the hard part, the vision is always easy...

I am currently in the process of implementing a TLV message protocol (think MsgPack, CBOR, etc).

This is something I've been kicking tires on since my time at $BIGCORP; JSON without the bloat, Protobufs without the ceremony. I've drawn a lot of inspiration from MsgPack, CBOR, and Ion 1.1. Big emphasis on a tight set of core primitives, low-cost extensions, storing reused values/schemas, optional pre-negotiation, etc. That said, I've now been spending time trying to study the performance angle to make sure the design doesn't have a negative impact on encoding/decoding performance before committing to the implementation.

Regrettably nothing much to show (at least yet), but hopefully if nothing else it will become my go-to format for other personal projects that I work on.

I'm working on a new memory-safe systems programming language that is supposted to be (almost) as fast as C, Rust etc, but as simple and concise as Python: https://github.com/thomasmueller/bau-lang

There is a playground which is using a C compiler and WASM, and so is quite fast, while running fully in the browser. Theres also a (online) conversion tool to convert and compare source code. There are some benchmarks as well.

Writing my own (concise, simple) programming language was a dream for me since I'm 20 or so. Feedback would be great!

I got tired of repeating myself to LLMs over and over so I built context-llemur

https://github.com/jerpint/context-llemur

It’s a CLI/MCP context management tool that allows you to easily move your project context around to your favourite LLM clients/IDEs

"WithAudio", a text to speech solution for Desktop.

https://desktop.with.audio

The most important features (for me) are: One Time Payment and 100% local and private. I don't send any data to any server. Just enough to verify license keys.

- Its one time payment, user can import any text, URL or ebooks and use the reader with read along text highlighting or export the audio as mp3 or m4a (audiobook specific format).

- Currently only supports MacOS with Apple Silicon I was doing Windows too but its making development slow, so I'm pausing that for now. - The most recent feature I added is Global Capture where user can setup some hotkeys to import any text and URL. Text parsing and extracting text is one of the hardest part of this. - Also, just added the a Reader view to website. Its goal is to mimic the app featuers as much as the browser limitations allow. I don't have a free Tier but a 7 days money back gurantee.

I mostly have a dev and engineering background but the most exciting aspect of this marketing and those stuff. Still trying to figure that.

I'd be happy to hear any feedback and ideas.

Edit: Only English at the moment. Adding more languages is in my plan but its very difficult for me since I don't know any other languages. But I think it would be great to add those as well.

I'm working on Beam, a web app that lets you transfer files between nearby devices using QR codes - completely offline, with no servers involved, and leaving absolutely no trace.

Beam is perfect for sharing sensitive documents, transferring files when you can't use USB, email, or cloud storage.

Try it here: https://get-beam.vercel.app

I’m currently 4 years in to doing everything possible to build the best budgeting app https://envelopebudgeting.com

This week I’ve been working on predicting upcoming paychecks with Nodejs so we can automatically decide how much funds to move into your budgets when you get paid. I pull the past 3 months of transaction data from our Postgres database using Prisma and run some analysis.

People think syncing and delayed transaction data is normal, and I’m working on changing that by having the budgeting built in to the checking account. Along with a high yield savings account, goal envelopes, bill envelopes, etc, joint accounts, etc.

I'm building an insurance business, I guess?

I was not satisfied with the health insurance advice available to immigrants, so I paired up with a broker. When my content and my calculator are not enough, they can reach out to this guy and get a recommendation. I monitor him closely and make sure he prioritises honesty over revenue.

The update was a little too successful and I overwhelmed him with new customers. He's now working long hours to cope with the demand, so we have to build infrastructure to streamline things a bit. We need to automate case tracking, document collection, application with insurance companies, that sort of thing.

My actual job is to write useful guides for immigrants [0], and I find insurance quite boring, but the high commissions and high conversion rate make up for the loss in traffic to ChatGPT and Google AI summaries. It also gives me a lot of insight about the insurance industry, which in turn helps me improve the advice on the website. I get clear data about which insurance options work for visa applications.

If all goes well, I can eventually get back to the stuff I care most about: helping people settle in Germany.

[0] https://allaboutberlin.com

I've been building for some time a local production like environment running in Minikube, deployed in a single `terraform apply` command. The plan is to deploy in one command a couple of home made services, frontend, backend, some websockets in between, and have everything accessible over HTTPS via Ingress resources. That, and all the open source observability tools you can imagine (Grafana/Prometheus/Loki/Tempo), configured and running at once.

See https://github.com/chazapp/o11y.

These last few days I have decided to try getting Kubernetes Gateway API to work, using the implementation of Istio. I have written an `auth` microservices which provides JWTs and published a public JWKS endpoint, and intend to have the API gateway validate tokens and claims to allow access to other services. The plan being to write API services without any knowledge of the authentication systems that happen upstream. If a request reaches them, it's that it had been validated before !

Currently thinking about better ways to spread the word about https://theretowhere.com (my website that makes it easier to find apartments and Airbnbs/hotels close to things you care about).

I've actually started getting some back and fourth feedback with a couple users, which has kept me motivated and validated. But I need more organic traffic somehow. I've recently released a new usecase (https://theretowhere.com/vacation) that might be more well suited for vacationers, so let's see if that sticks.

Funny anecdote from today - I just set up Slack notifications so I get more instant knowledge of errors on the platform, and the first notification came in just a couple moments after I deployed. It was for an error that I thought noone would run into for a couple days. Imagine my (bad) luck!

A CLI tool to make reasoning about Postgres locks a bit easier.

Given a database[1] and a set of DDL statements/migrations you want to check, pglockanalyze will open a transaction, execute the statements, read the pg_locks view to analyze the locks they acquire and rollback (or commit, depending on the flags you passed) the transaction. Then, it will output the results for each statement.

I think there's merit in this idea, that said it's very much an experiment so there could be flaws and/or corner cases that this strategy won't work well for.

It's meant to act as a complement, not a replacement, to things like static analysis and the official Postgres docs.

https://github.com/agis/pglockanalyze

[1] typically an ephemeral database spawned by your CI pipeline

I’m currently working on implementing a Minecraft server in Rust. Not a new concept, I know, but it’s a great learning opportunity. I already have a few basics like loading and saving worlds and placing/breaking blocks implemented. In a few weeks I will release the first version and host a public server for testing. Then I will also do a show hn. Repo link: https://github.com/T-x-T/oxide (better readme coming soon, don’t worry)

Working on https://openreaders.com – a platform with free graded readers, starting with Spanish (my native language).

When learning a new language, it’s surprisingly hard to find free, engaging reading content at your level. Even paid options often aren’t that great. I’m trying to solve this by leveraging LLMs, building useful features for learners, and focusing on user experience.

Just launched the beta yesterday on Reddit: https://www.reddit.com/r/dreamingspanish/comments/1matsp6/fr...

I've built a VST3 plug-in that simulates a Mesa Boogie Mark IIC+ preamp purely from the circuit.

The approach doesn't seem popular for professional plug-ins likely because it wasn't viable for real time until modern CPU enhancements became available. Performance scales with frequency of the input which is interesting and seems to be a consequence of using an iterative solver on a system of equations and using the previous sample's state vector as a guess for the current sample.

On my MacBook M3 it requires between 50 to 70% of a single core to produce a 2x oversampled output at 48000Hz. This can be scaled back by reducing the solution tolerance bounds and get down near 25% with minimal quality loss.

Still building https://ongoingthings.com - a way to document and privately share life updates with close people.

I used to post personal updates in group chats - scattered, repetitive, and easy to miss. Now each topic (like raising a child, a trip, a project) gets its own private space - an Ongoing Thing - where updates stay organized.

People get email notifications for new posts. There's no feed, no comments, no ads - just a calm way to stay connected.

We just added Partner Things so multiple people (like two parents) can post to the same thing. Our small user base loves it.

Still figuring out marketing. Until now, it's mostly been word-of-mouth. Feedback welcome!

A while back I saw an RF lightning detector on HN (https://techlib.com/electronics/lightningnew.htm)

I redesigned it to be much smaller and cheaper (surface-mount), made it an IoT device, and various other changes. Will order PCBs in a bit, hopefully it works well.

We don't have anything like Blitzortung in SE Asia as far as I know, and it would be pretty useful to me to detect lightning storms before they hit. The obvious application is to add it to my motorbike (driving a motorbike in a heavy storm is a necessary but miserable part of life here).

Bigger picture, there's no market for it, simply because it's cheaper to not buy one (I live in a very cost-driven market). However it would be useful to me personally.

I'm writing an encrypted and padded IP tunnel to help people build their own multi-hop circuits to access the internet anonymously, without Tor, and with protection from end-to-end correlation attacks.

https://github.com/markasoftware/i405-tunnel

I'm working on an AI spreadsheet platform called Sourcetable (https://sourcetable.com).

Most people use it for analysis and ops work, + data science.

I find myself using Sourcetable to run our company: query the DB, analyze the user data, make projections, write copy, help with technical SEO (search the web, scrape data, check status codes, clean my sitemap, run vector space analysis etc.), talk to apps, financial modeling for our operating model + forecasting, etc.

The main idea I'm thinking about is LLM related: we're all having a social experience with machines (!) while building the machines (!!). I'm not sure my brain fully grasps that it's talking to silicon while I work.

An offline-only translator app for Android, using Mozilla's translation models (on device) and Tesseract.

App is alpha quality but working: https://github.com/davidventura/firefox-translator

Trying to figure out F-Droid publishing..

I am working on a world model for computer systems (world).

Do LLM Agents really understand Linux?.

"Understanding" meaning.. can they predict the outcome of their actions before executing them? Computer system is irreversible.

World model for computer systems is crucial next step for computer use agents to reliably plan their actions over long horizon.

Links to draft: https://open.substack.com/pub/disastermanagementtechnologies...

I published 2 (two!) new chapbooks of poetry, both priced at $0.00:

> Sonnets of dark-held love - A sequence of poems after the 'Sonetos del amor oscuro' by Federico García Lorca - https://rikverse2020.rikweb.org.uk/book/sonnets-of-dark-held...

> End Time - A collection of noir-themed poems for the last days of the world - https://rikverse2020.rikweb.org.uk/book/end-time/

I'm working on an open source wrapper and MCP server to give Claude Code voice capabilities (and Slack and WhatsApp messaging). It works with system default TTS and google free ASR on Mac out the box but allows you to BYOK to your favorite TTS/ASR provider. I've also tried to make it a viable python library to make it easy to switch between ASR/TTS providers.

With Claude Code I really like being able to multi-task but right now it's a bit like a Tesla on autopilot needing your hands still on the wheel. With TalkiTo I can do housework/go out for lunch and keep it on the right track remotely.

https://github.com/robdmac/talkito

I'm working on Waywo, a semantic search engine for "What are you working on?" threads powered by new features in Redis 8 like the vector set data structure for semantic search.

Waywo will help users quickly digest hundreds of project descriptions, explore similar projects, deduplicate projects across threads from previous posts, visualize a graph of all projects, and more! I'll be documenting my approach to building this with coding Agents like cursor and Gemini CLI

I'm building Waywo for the Redis Hackathon on DEV.to that is running from now until August 10! Follow me on DEV/GitHub/X (@briancaffey) to see how this project turns out!

Two things:

I am building a Pinterest clone that filters out AI generated imagery[1]. It is built on top of Bluesky so gets the benefit of its large library of well alt-text'd images, which aids with search.

Also working on a new kind of social media, where every user is a verified human[2]. The idea is to avoid the problems that sock puppet accounts controlled by the rich and powerful can have on our society. Again, I am starting with Bluesky as a target demographic and have already had some adoption.

1 - https://scrapboard.org

2 - https://onlyhumanhub.com

We just open-sourced a server that implements the Model Context Protocol (MCP), designed to connect LLMs and AI apps (like Claude Desktop, Cursor, and Windsurf) directly to Decodo’s platform — no glue code required. This makes it easy for agents and copilots to access the web, retrieve structured data, and run real scraping tasks through a common protocol. The server includes built-in tools for things like: Scraping websites as Markdown Running Google or Amazon searches and returning parsed results Controlling geo-location, language, and token limits via prompt It’s privacy-conscious, region-flexible, and works out of the box with most MCP clients. You can run it locally, or install it in one click via Smithery. We’d love feedback from developers working on: LLM agents or autonomous tooling AI-based research or retrieval systems Scraping pipelines or data orchestration tools Here’s the repo: https://github.com/Decodo/decodo-mcp-server

Let us know what features you’d like to see added, or if you run into any integration issues. We're actively improving this based on early use cases and real-world friction. — The Decodo team

Software for biomedical research labs.

Animal colony management is largely managed in Excel sheets, with no integrations to related systems or hardware sensing. We're working on the spreadsheet problem first, so that biomedical researchers can share information about their colonies with other researchers at their institutions, and explore the lines that other labs have. This opens up collaboration options and makes it much easier for the research community to find out what mouse lines other labs have (and may borrow for their own experiments).

https://www.mousehouse.bio/

Currently in closed beta at Harvard

I’ve been working on an animal management app for the last two years or so. It’s a hobby project so it’s not going very fast. Recently I’ve released a new version with support for one model of a UHF RFID reader. It allows me to count and identify my chickens from up to 15 feet away.

https://youtu.be/_iGn_pZ3IkY?si=x4ijZdAP-suhuJ7Y

https://apps.apple.com/us/app/manger-animal-manager/id674269...

I'm currently working on DSC, a tensor library I wrote from scratch in C++ with a PyTorch-like API.

Right now it works on both CPU and GPU (both AMD and NVIDIA) and is capable of running LLMs like Qwen, I'm currently implementing a native profiler to trace CPU and GPU kernels and then I'll work on speed. Goal is to be competitive with PyTorch eager by the end of the year.

Source code: https://github.com/nirw4nna/dsc

My original HN post: https://news.ycombinator.com/item?id=44310678

I'm building a CVD system to make arbitrarily large single crystal optical quality diamonds. Not a coder, so I'm using ChatGPT and Claude to show me how to integrate microwave power sources, vacuum & gas supply systems, and other subsystems with LabView. As Gust said in Charlie Wilson's War, "We'll see.".

I am working on DataGrid Toolkit. Based on my experiences building and selling (Excel like) data grids, people always look for your data grid, "but can it do this"? With DataGrid Toolkit, a developer can choose his own building blocks/modules and make a more Excel-like data grid, or make a more DataTables style traditional paginated table. The toolkit is headless and stateless by design and comes with different renderers. Canvas, html or some hybrid. It is written in Typescript and the data store is in Rust/Webassembly.

I have been working on building a site where you search by phrases which you have heard in some youtube shorts and are not able to remember which video was it, my project would give the users the videos in which the phrase has been said or mentioned

I've had a notion that LLMs can read Typescript types much better, than JSON schema types.

So, I've been tinkering around with a library that can generate schemas for structured JSON outputs, according to a Typescript-like custom schema definition: https://github.com/nadeesha/structlm

So far, I've been seeing promising results with accuracy on-par or better, but using 20-40% less tokens than JSON schemas.

I'm working on hessra.net, a token-based authorization system for machines and built using biscuits. The idea is that any service/machine/IoT device can authenticate to the service and get authorization tokens for each request based on policy. Then the tokens can be included with the request and verified without any further RTTs using the service's public key. The tokens are meant to be single-use and scoped to a single request.

Besides the simple "get token and send to a thing that uses it to authorize a request" there's a couple of things we've built/are building on top:

service-chains: for a given resource, you can configure the token so that it needs to be signed by notable components along the path of the request, and at each step along the path check that it was signed by expected components up to that point. the thinking is this could really cut down on lateral movement in a system

multi-party authorization: for a given resource, you can configure N authorization services that also need to sign the token based on their policy. the token only authorizes if all parties have signed it. this could be useful for managing capabilities of software deployed into customer environments or perhaps for b2b agents to get signoff from both b's for doing an action

I often need a PostgreSQL server for testing an application, vibe coding, or troubleshooting a PG client. Inspired by Neon's architecture, I implemented PostgreSQL WASM (PGlite) with a cloud proxy (via Websockets) at https://postgresql.dbfor.dev

All the PostgreSQL data lives in your browser, and you have unlimited PostgreSQL servers that persist the data locally without installing anything.

I've been learning systems programming for a while and recently I discovered kilo[0], which inspired me to start building my own editor[1]. Not sure how far I'll go, but hopefully it will be usable -- how fun would it be to build another project of mine using my own editor?

[O] https://github.com/antirez/kilo

[1] https://github.com/bloomca/love

Some folks I work with have a terabyte of short string records that they regularly scan with regexes to develop classification criteria; it's a prime application for a substring index that can accelerate their queries, but the scale is daunting.

I came up with a suffix-sorting index for this domain that's interestingly simple. Most algos for this use a generalized suffix tree that's built by concatenating all the strings into one giant string and feeding it into a conventional suffix sort, but that has some big constants on the indexing throughput, due I think to the overhead of handling one giant string instead of a bunch of small independent records.

In the latter case, by making the structure slightly simpler and search slightly harder, I can get indexing throughput in the GBps, at least for the sorting part.

The output of that in its simplest form is a 4n or 8n-sized set of int's, but it can be fed further into a compressed rank/select data structure for various space/indexing time/retrieval time tradeoffs, and I don't think those are slow (eg Roaring Bitmaps)

I'll post this on show HN if anybody's interested; I'm still writing up the details, as I've barely gotten the POC code working.

I'm heads down building a workflow pipeline builder that executes Wasm Components as part of individual nodes within the pipeline.

Think Zapier or n8n, but you either use existing processing nodes or upload your own code, written of course in any language that compiles to Wasm Components.

It's week 2 but it works and it's live at https://pipestack.dev

I've been working on an encrypted environment variables management tool, called kiln[1], for teams. I know, tools like age and SOPS exist, but this partly came through because of the lack of a good UX around the encryption part especially for a team-based workflow. I aim to continue building kiln as a developer-first experience, making it seamless to integrate into a large team's workflows.

The idea came to me when we were trying to find ways to manage Terraform secrets , CI vars were a no-go because people sometimes wish to deploy locally for testing stuff, and tools like Vault have honestly been a pain to manage, well, for us at least. So I have been building this tool where the variables are encrypted with `age`, have RBACs around it, and an entire development workflow (run ad-hoc commands, export, templating, etc) that can easily be integrated into any CI/CD alongside local development. We're using this and storing the encrypted secrets in Git now, so everything is version-controlled and can be found in a single place.

Do give it a try. I am open to any questions or suggestions! Interested to know what people think of this. Thanks!

[1]: https://kiln.sh