Ask HN: What are you working on? (September 2026)

17,000+ users already! It's a completely ad free, subscription free product. MacroCodex app, which results in guaranteed weight loss or weight gain outcomes within 2-3 weeks. Many people will start seeing results within the first week. Don't believe? Read the reviews.

MacroCodex is a "Total Calorie Burn of the day tracker" using completely sensorless method explained here: https://macrocodex.app/knowledge/macrocodex/smart-calorie-bu...

CalorieCodex - calorie tracking app which has a Agent Harness built in using BYOK (bring your own key model). How does it help? Using this anyone can track calories and plan their meals. Agent includes skills which help you accurately track calories.

Symbiote App - Think "BoostCamp" but completely free, no ads, and fully programmable workout tracker

I’ve built two (successful) iterations and am now working on the third. They are all very minimal.

The main one works well and runs full time waiting for my next idea. The second targeted an open weights model and worked in limited cases.

Now I’m working on a more autonomous version. I give it only a goal and a strategy, it decides its own projects.

Probably the most interesting thing about it at the moment is the editor. The world, and most things in it, are represented as collections of SDFs. More accurately, they're density fields, but, potato-tomato.

Bonsai has undergone a large rewrite over the last couple years that's nearing completion. A world edit is defined as a bunch of SDF parameters which get projected/rasterized into the voxel grid by a shader on the GPU. One neat thing about SDFs is they've been thoroughly researched and documented by a guy named Inigo Quilez, and they have a lot of nice mathematical properties. For example, you can do a smooth union of arbitrary SDFs to get nice rounded contours where shapes join.

I've written every system from scratch, all the way from the memory allocators and font rasterizer to the collision detector and simulation loop. I even wrote a metaprogramming language as a replacement for C++ templates, which is a whole other story. IIRC the only external dependency is the C runtime library for starting the process and my very occasional use of variadic functions arguments.

For a long time, an explicit non-goal of the project was to ship a game. It sounded insane to me to write an entire 3D engine and then ship a game. As it turns out, I've gotten it to the point where I can actually make a game. I've got a start on the game systems in a closed-source repo, and hope to have a steam page for it by the end of the year.

I'll do some shameless self-promotion and leave some links here for anyone interested in looking at the engine, language code, or some pretty pictures.

https://github.com/scallyw4g/bonsai

https://github.com/scallyw4g/poof

So over the years me (and my team) have built up a lot of experience dealing with these for sensitive industries like healthcare/insurace/lending etc.

We are bringing these ideas out as a router to other parsers, but with some key takes that allow you to manage failures. "Failure is inevitable so route for it."

It is called Openreading - https://openreading.ai/ and open core here: https://github.com/openreading-ai/openreading-core

It is still WIP and will be more polished in a month after some more rigorous testing and benchmarks.

If this is a problem you deal with, would love to chat.

Note: the intent is to launch a managed version that provides more durable compute/retries, parallel execution, intent understanding etc but this is for later.

The app wraps whatever is playing on mac through device convolution (old radio, hifi system) - Room convolution (a bedroom, a forest) and adds ambience (rain, wind, waves) and Apples spatial processing - so it sounds like a real space.

For me - hearing the sound in a space really helps more than just the dry sound.

https://www.surraura.com/

At the moment, even if you set up SSD for foreground operations and HDD only for background, more often then not, your write latencies are those of the HDD. We can do better.

See https://paquari.com/posts/bcachefs-ssd-hdd-progress/ for a progress report. (Disclosure: the write-up is an AI summary of my notes, so don't expect any brilliant prose.)

I'm also working on resurrecting stabilizer (https://github.com/matthiasgoergens/stabilizer). Stabilizer is a way to make program performance less dependent on the linker and layout lottery. But it has sadly fallen victim to bitrot.

I'm doing some minor contributions to other parts of Linux like ZFS and ext4, mostly as a byproduct of experiments I'm running for my bcachefs work. Another somewhat ambitions project is to make swapfiles on ZFS and bcachefs work (or work better), at the moment the problem is that writing swap on them might need to allocate memory exactly when you are out of memory.

https://github.com/AttemorySystem/spire-agent

A retrieval engine that using attention to retrieval, achieved several SOTA results on multiple benchmarks(LongMemEval, LoCoMo, code search, etc)

https://github.com/AttemorySystem/attemory

Traditional error trackers have two failure modes:

1. False positives: They show you thousands of errors, and you can’t tell the impact on the user

2. False negatives: Many user-facing issues don’t throw exceptions, so they go unnoticed.

Opslane combines error tracking and session recording. And there is an agent that acts on both.

Opslane reduces false positives by ranking issues based on how many users are facing a particular issue. It also learns about your product by reading your code and watching your session recordings.

False negatives are harder. Opslane reviews session recordings to spot frustration. They look for rage clicks, dead clicks, and abandoned forms.

Here is a link to the repo: https://github.com/opslane/opslane

Also, an orchestrating agent that supervises subagents running tasks by checking their output and qualifying their results by efficiency and time consumed. It is amazing!

I am currently building an app every couple of days, but with this orchestrator I can build many apps in parallel. It is raw at the moment but it works

Now the time we spend writing prompts will be spent writing plans, tasks, schedules and metrics. While super interesting, this is definitely not the route I want to take for the sake of my sanity. I think we may start asking our model to write plans and tasks for us too, but the more complexity we add, the more complex thoughts we have to manage as AI architects

Also hacking DeepSeek Harness to circumvent all restrictions it has, giving it super powers to run unattended with full access to everything

After being frustrated with outdated & inaccurate data Claude used when I was trying to do some property research, I thought it'd be cool to build an MCP that can provide accurate property data. Then it evolved into a full web app + an AI assistant.

This was also an excuse for me to try DuckDB in a real project. All the API endpoints are powered through in-process DuckDB querying parquet files stored in disk.

I already partially covered the last few months of app development in this topic. But actually, its development took way longer, as only this iteration started in 2024. So it is the end of a long milestone— this launch date initially was to be a year ago, but I procrastinated and missed important for such apps holiday season

This year I was able to go way beyond last year’s backlog, and now I’m releasing a fully finished app instead of early access.

I’m proud of the result — a lot of overengineered stuff that is not viable in any commercial product, especially in what appears to be a simple CRUD app. For example: image loading from blur, unadvertised but very advanced DnD everywhere, natural language currency inputs with sorting, platform-agnostic quick add, and many more.

Its stack is also very fun: it has been running on the Cloudflare Workers ecosystem since 2023, and is powered by a custom Inertia.js adapter for Hono (that predates the official adapter by one month, lol), with Vue SSR. That all enables me to write old-school MVC with Vue as a template engine for views. It also proved to be very easy to work with and cheap to run.

With a tsunami of vibcoded beige wishlists, my weird app stands apart, for sure, but I’m unsure about its appeal to the average customer.

Meanwhile, Daniel Greene's dodgy whiteboard video has a million views. Don't mind me as I eat these sour grapes...

I've also written a plaintext to QTI quiz converter since creating quizzes on Canvas is so slow (I realize, of course, many other people have already made these... I just happen to like mine). It currently supports fill-in-the-blank, multiple choice, matching, true/false and word bank style questions. You can also generate a printable (DOCX) version of whatever quizzes you make.

Here's the site: https://www.hacksforeducators.com

All the tools are free, and there's no login required. So if you are a teacher that uses Canvas and think any of these tools could help you, check them out!

https://supso.org/projects/sup-xml/docs

https://gitlab.com/prbs23/freefall_800

The smoker hardware itself is pretty good, but like most IoT devices, the firmware and app sucked. So I reverse engineered the whole control PCB, and have been rebuilding new open source firmware from scratch. All the basic functionality is working now with a fully local control web app. Plus an Andoid app, and Home Assistant integration.

Currently working on interface refinements, and some more advanced control sequencing features.

I wrote up all the reverse engineering details in a blog post here: https://www.prbs23.com/blog/posts/reverse-engineering-gravit...

Last year, Mozilla released Orbit, an AI-powered browser summarizer hosted on a GCP server. After people started digging into the extension, they discovered things like backend endpoints such as store_result. Eventually, Mozilla discontinued the project. For the past month, I’ve been trying to rebuild Orbit from scratch, but with one major difference: Apogee is fully local and privacy-focused. Apogee doesn’t send or store your data. It can directly connect to your local Ollama instance for inference. I’ve also added WebGPU integration for Chrome and Transformers.js for Firefox to provide faster, local responses.

It can summarize: Articles and websites, YouTube and Billie videos, Wikipedia articles, Hacker News and Reddit threads.

You can check out the source code here: https://github.com/darshi1337/apogee

Install Apogee:

Chrome: https://chromewebstore.google.com/detail/apogee/pgemlpomhkdc...

Firefox: https://addons.mozilla.org/en-US/firefox/addon/apogeeext/

Obviously it is far from complete. Would love to hear your feedback and suggestions!

- Flexible rp2040-based instrument tuner

- Stratocaster-style PCB art pickguards

- NeXTBus experimentation board (not that I'll ever use it, but I'll be darned if I don't understand the nuances between NeXT and Apple's NuBUS implementations better now)

This extends to firmware and emulation projects like Doom and the Quake trilogy running in Jira Cloud (https://marketplace.atlassian.com/apps/3372062249/doom-for-j...) and a fork of 86box dedicated to NeXTstep systems (i want an emulated object.station, darnit)

I have slowly built out a set of tools for asteroid orbits and photometry (measuring how bright stars/asteroids are).

It is very rough still (Desktop only), and it only supports the FITs file standard.

https://www.astrometry.space/

Basically it is a full professional grade telescope processing pipeline in your browser. It does 2 queries to some custom databases to identify known asteroids and stars, but all image processing and calculations are done in the browser. This means the backend is pretty tiny. That said it is running on an old box in my closet, so queries may take a while if it gets hammered.

I built it since I have worked with quite a few astronomers over the past 4 years and I keep watching them do the same steps, purely built to make my friends lives easier. I wrote it all in rust and managed to compile it into wasm. With some help from fable as I am not a frontend guy at all, I built it into a small website.

Some of the code is public, the orbital mechanics code I wrote while I worked at Caltech. Which is being used on SphereX, NEO Surveyor, and the Roman telescopes to identify known asteroids. https://github.com/dahlend/kete

My secret goal is to figure out how to make software development the kind of focused, meditative work it used to be.

https://clor.com

Very happy to get critical feedback from any HN'ers: jake@clor.com

https://news.ycombinator.com/item?id=49686888 https://agentspork.com/

The basic idea is to separate an application's UI semantics from the toolkit that actually renders it. The same application can currently be presented using native Win32, Cocoa/AppKit, Qt6, GTK3, GTK4, Swing, or a web browser. The UI can run locally or be rendered remotely by a client, without the application itself being rewritten for that environment.

I've also been working on a declarative layout format and, lately, a visual designer.

It started as a rewrite of an architecture I worked on many years ago, mostly because I wanted to see how far the idea could be pushed with modern systems. It has turned into a considerably larger project than I expected.

Still private and very much under development, but I'm curious whether other people have run into the same problem: maintaining applications that need to survive changes in GUI toolkits, operating systems, deployment models, or client environments.

To signup you don't provide any information (a randomly-generated account number is assigned to you), and you can run a proof-of-work captcha to get 2h for free. You can choose among many different search providers (for defaults and per query), including Uruky Site Search, powering our own index.

Last month we reached 300 monthly active accounts and released an image search gallery mode, plus a simple calculator and conversion widget!

The main differences between Uruky and Kagi, DuckDuckGo, SearXNG, etc. are visible in the footer (right side), but one huge difference is that with Uruky, after being a paying customer for 12 months, you get copy of the source code (licensed as BUSL, into AGPLv3 in 2 years — a suggestion made here on HN)!

Our main challenge continues to be discoverability and outreach because we want to do it ethically (no Big Tech and no GenAI/LLMs). Ideas are welcome! We’ve been sponsoring open source projects, open source maintainers, and indie, small-web, and privacy-related websites and applications/groups/orgs. This month we're sponsoring NOYB [2]!

Feature-wise, for September the most visible things that shipped already were Tags and Scopes (top feature requests for a while). We’re also still (slowly and sustainably) increasing our own index, focused on indie/small web.

Thank you for reading this!

[NO-AI]: There is no generative AI product or service being offered, here.

[1]: https://uruky.com

[2]: https://noyb.eu

The audio itself is in delivered with the restored classical Latin pronunciation and contains spoken nuances like vowel nasalization, elision, and prodelision. I used a wav2vec2 model to generate forced-alignment data, so you can easily follow along with the text as it's being read aloud. Each word in the text is richly enhanced with pedagogical details like: lemma, citation forms / principal parts, morphological segmentation and analysis, inflectional class with complete declension/conjugation tables, verb category, contextual lexical information (i.e. specific L&S sense), Classical Latin IPA pronunciation, UD style syntactic function and relations, predicate valency, and concise English definitions. Spoken instances of elision and prodelision can also optionally be displayed.

From a nerd perspective, one of the things that makes the system interesting is that the documents themselves are entirely in XML, and I use the soon-to-be-removed-everywhere in-browser XSLT feature to render the HTML, so you can see the underlying XML structure if you view source. Each sentence in the text contains provenance records so you can see the language model and parameters that performed each language enrichment task. The site UI is largely bilingual, and you can view it in either Latin or English.

https://www.harborgit.com/

https://ffmpeg-commander.com

I originally built this around 7 years ago in Vue2 and Bootstrap as a simple static frontend tool to generate common ffmpeg commands.

I recently ported it over to Vite/React/Tailwind via Claude (Opus 5) and thought it did a pretty good job. So refreshed it as a version 2.0.

Quite impressed how fast AI was able to port this over. It made me think about revitalizing some old projects. :)

Since last month, our four Google Summer of Code interns finished their projects.

University of California San Diego has deployed our Wayfinder and Waystation web apps for their 35,000+ students!

We launched a redesign of our Android app.

Our next-generation server software, Maglev, is almost at v1.0!

We are always looking for more developers, biz dev, ux designers, product managers, and more to help out!

Open volunteer positions: https://ossvolunteers.com/organizations/open-transit-softwar...

Our software: https://github.com/OneBusAway/

More about us: https://opentransitsoftwarefoundation.org

https://www.balladlabs.com

My last company (Courier, YC S19) had great inbound but we never were able to scale it. Ballad plans what I should write, drafts in my voice, publishes to my accounts, and handles attribution so it can feed that into what it writes next.

There are a lot of small languages in the world, and translation used to be extremely expensive. And there is never too much good space sci-fi.

(We don't write space battles or wars. Our style is slower and bit more philosophical. Light speed is the limit, and travel takes centuries.)

Why? There's no why. The world doesn't need another Markdown editor. I still made one.

Everything is on-device, purposefully human-centric without being anti-AI. I built this because I wanted to work on a project that I could sweat the details unconstrained by deadlines, investors, etc.

I was frustrated with other writing experiences, and like most I gravitated to Apple Notes due to simplicity, but I still missed so many things. As someone that's spent the last 2 years immersed in Cursor, Codex and CC, I wished some of their input behaviors existed in a regular text editor.

For example, you can use / to add styles, or : to add emojis, shortcuts like < 3 for a heart, - > for an arrow, and so on. It honestly feels great.

Is it radically different than other editors? I don't think so. But I think it's well executed across every dimension possible.

Maybe one different thing: multiplayer. It's live editing like google docs, but P2P using WebRTC and strong cryptography. The limitation here is that you can only share a file while having it open yourself.

Great care was taken to performance and portability. This is one of the areas where I spent a ridiculous amount of time simply because I enjoyed pushing the limits of the stack. While using you will notice that rendering, GPU, RAM and bundle sizes were heavily optimized. The Mac app is < 50mb.

Very soon, I'll launch an iOS version with iCloud sync. In the future, I might launch basic AI features. If you miss a great text editor in your life, give it a try.

For that matter, I also decided to self-host SourceHut because I will no longer be in compliance with their new policy. I have the flakes set up to inject them on my server [2]. This was very AI assisted.

[1] https://git.brucewillis.sexy/~tombert/fs_index I promise it’s safe for work, despite the URL. That’s just my dev URL that I play with. Code is still a mess though, so proceed with caution. I will eventually clean it up.

[2] https://git.brucewillis.sexy/~tombert/sourcehut_flakes

Really exciting stuff is happening literally every month, because underlying models are getting better and better. When I started it was pretty basic: “make a cube with a hole through it”. Now it’s at the point “make a raspberry pi 4 case” and the agent searches, builds, verifies…

What surprised me in this process is how little meaning AI benchmarks have. Pareto frontier for my use case looks completely different than any other benchmark portrays.

https://gitsocial.org/ https://github.com/gitsocial-org/gitsocial

It started with a family member telling me they were frustrated with existing websites. What I noticed is that in many cases they feel cluttered and not smooth to use, almost like a 1-to-1 translation of the underlying database queries, where they have you choose filters and sorting options upfront then browse the paginated results.

I wanted to avoid all of that by creating a different experience; I built an interactive full-screen wall UI with infinite browsing so that most of the screen space is dedicated to the core content. I worked on the name sampling algorithm to try to make it as enjoyable to browse as I could, and the only filter displayed by default is the one to select genders.

More advanced queries are available through the search field which supports natural language queries, running on a local multilingual interpretation engine with a cloud LLM fallback. The database engine is custom built with Rust, compiled to WASM for higher performance when running on CloudFlare Workers. I don’t use an external DB service for names today.

What I’m pretty proud of is to know a lot of technical work is hidden behind that UI, and how it has been shaped by the experience I wanted instead of the other way around.

1. A robotics information and news website. Any feedback is appreciated. https://robotica.dev/

2. Applied DBSP theory to Postgres https://github.com/getravi/pg_dbsp and DuckDB https://github.com/getravi/duckDBSP. The idea is to have incrementally maintained materialized views.

You’d start a reading session and the dragon would read alongside you. What you read would influence its appearance and habits; lots of sci-fi might give it starry wings, for example. It won’t die if you go a week without reading.

The plan is to keep it playable offline, with optional syncing to Booklary, the reading tracker I’m building. I’m leaning toward C++, which I never used, so it’ll be a learning experience.

Currently waiting for the Waveshare board to arrive so I can start development, and looking for an artist to commission the pixel art. Used GPT to design a concept[1], which I’ll use as examples to the artist.

This will be my first ESP32 project, so getting the dragon blinking on screen is the first milestone.

[1]: https://i.cpimg.sh/57EC5380-0FF7-4646-A943-971350FF98D2.png

https://video-commander.com

Constantly and carefully iterating through refinement and features. It's built on Rust + Tauri with a React frontend, in case anyone is curious.

I've created various open-source and commercial tools in the multimedia space over the last 10+ years and wanted to put it all together into something more premium with an IDE-like experience.

Most recently I added a /playground area to experiment with the inspection tools via a WASM build, which I thought was a neat way for users to try the app before downloading the full version.

Happy to answer any questions!

It’s an AI Private Investigator that does the hard work of data gathering (using Open Source Intelligence) and correlation. Used by over 70k investigators including government agencies.

https://github.com/slyall/auckland-stop-display-simple

Some other projects doing similar stuff but I found they were hard to understand (and mostly used an old API that no longer exists) so I (well AI) made mine with small scripts and included curl examples.

https://github.com/mcdirmid/cleanroom

So far I have bazel macros up that can produce tested code with a ~30GB MoE model (Jundot/Qwen3.6-35B-A3B-oQ6-mtp, I can get ~90 toks/sec on a M3 Max!) using cleanroom separate implementation and test development (and then comparing them until both are correct). Over the last month, however, I found that my bottleneck is in the specifications: as I further divided my components into separate parts (since smaller components are easier to write and test), I started hitting problems with specifications becoming badly ungrounded (code depending on knowledge they cannot access, so something is just hallucinated).

So I redid the format, e.g.

https://github.com/mcdirmid/cleanroom/blob/main/update_with_...

The spec format is designed to be declarative and very modular, and ya, an LLM is primarily writing the specs as well, so I hope to create some sort of formal reasoning framework that the specification can be translated into (by an LLM) so that ungroundness feedback can help the LLM write better specs. Also, I found that it really is much more robust to change/refactor/add features via the spec first and then align changes down to test and code, then to make changes to the code directly (even without using the system, just asking a frontier model to look at the guides and do the alignment itself directly).

I think I'll be ready to do a release over this next month, which means:

- Supporting a build system other than Bazel to express DAGs. Honestly, this could be anything, I just chose Bazel for convenience (easy to express graphs in Starlark), but it assumes a monorepo world that I don't think many developers use.

- How do I even package this? The advance of using Starlark is that I can generate python code to call into the generated python code directly. If I move away from that, I need to figure out what this really looks like as a binary.

- More demos. Right now my only project is the code for the system itself (the classic "the first program of a language is the compiler for the language"). I just can't think of many interesting things to do in Python that aren't agent related (I can support other languages, like Java, Typescript, or even C++, but I'm hitting choice paralysis).

My goal is to better understand the economics of AI and make something useful in the process.

(Coming soon: kWh prices and robot prices)

Mostly built with claude code with a dash of codex.

A recent, useful unlock in the process has been a daily CC routine to check the health of the 53 price collectors in the project.

This simplifies the setup for researchers who want to simulate materials science problems like battery electrode performance on GPUs with a simple usage-based pricing model instead of traditional HPC

https://github.com/patrickjh/ssa

https://cantelop.com/

- Minimal setup - Any agent harness - A session is an actor - Opinionated infrastructure - Performance on the critical path

I'm a Senior Eng on Wall Street, so I have my own personal experience with this problem, but i'd love to connect with other leads, release managers, etc to get their thoughts, suggestions, and what their current process looks like.

Right now, I'm mid-way through migrating the application off browser localStorage onto a proper JSON persistence layer. My first large solo project as a busy student.

I hope to make it better as I continue.

https://github.com/Disla-Novo/Dimidium_Bellerophon

The app is very customizable, local-first and is built to adapt to what you want. Goal is to combine habit tracking, health logging and journaling into one fast and easy to use interfact.

Have been working on it for almost years now and it's making great progress.

Doing closed user testing right now and will release an open beta soon: https://dailyselftrack.com/

My Astro Web Starter is built for building well-designed, performant and accessible websites. It contains everything a high-quality website needs (In my opinion). I built it so I have one good base on which to start my web projects on. Using basic HTML and CSS that can scale, without bloat.

There's a lot more on it which you can see here: https://starter.bryanhogan.com/

README is very bare bones, needs a video or a picture too. The website should tell you some more things: https://kavla.dev (and now the demo does not require a login (also need to remake the demo to fit the new self hosted version))

It's still lacking an analytics agent for the local version though. I've explored using codex CLI, but it feels like its extensive system prompt cripples the agent a lot vs Kimi 2.7 that I've been using in the cloud version.

I think it would also be nice to lean into the fully local LLM setup too, especially for data that shouldn't leave the device.

Hope that is no problem that I use this thread a bit for self-promotion. If so just write a reply I'll remove this comment if this is a problem

well, claude is: https://modus-lisp.github.io

https://github.com/viggy28/streambed

- an open source AES67 hardware receiver/decoder - based on my friend Jessie's work [0]. I want speakers to have ethernet ports and to use an open/inexpensive stack. it's hard because physics/timing are brutal (1ms sync is ~not enough), but that's what makes it a great problem.

- an open source embroidery machine - based on my friend Owen's work [1]. Owen found Brother PE-150 machines which are readily available on eBay for ~$100 as they only work with proprietary 90s-era CF cards which nobody has (or sell for more than the machine). he designed a replacement motherboard (!!) and is running a fully open stack. it's wild.

- a ~$20 tiny cute display you can have on the side of your monitor, and display things on - realtime airport view from flightaware? a mini terminal? you can grab a display today [2], all that's missing is a 3d case (email me for firmware/OS code! I'll share it, just haven't had time). friends Frank and Sophie are working on a similar GUD-compatible display as well! [3]

- my friend Antoine has been working on Python bindings to Canonical's dqlite, a distributed sqlite-variant with raft-based failover and transactions (only C and Go clients existed) [4] - this will soon be a structural ("load-bearing"! haha!) part of Disco, a project we've been working on for a few years which lets you run your own PaaS. we're growing and get nice love letters [5] which for an open source project is obviously deeply rewarding

[0] https://jessie.grosen.systems/projects/aes67-receiver

[1] https://owentrueblood.com/blog/2024/12/10/reverse-engineerin...

[2] https://www.waveshare.com/rp2040-touch-lcd-1.69.htm

[3] https://bsky.app/profile/sophie.engineering/post/3muxysxhpck...

[4] https://pypi.org/project/dqlite-client/

[5] https://infinitedigits.co/disco/

I built this because I think there's a lack of true realtime (CRDT) synced notes that aren't built on a heavy platform that take up 1GB+ RAM (Totem takes up ~100MB, and is also generally more responsive due to the local-first + ops-log approach).

Another thing I care about is keeping the underlying data portable: Totem is built on Markdown and SQLite as its core formats, so you get the convenience of cloud-based syncing without locking your data into a proprietary format.

I’m still looking for beta users/design partners before the initial launch. You can try it without creating an account here:

https://app.thinktotem.com/sandbox

And the landing page is here:

https://thinktotem.com

This is a bit of an unplanned post, so the sandbox template is a bit barebones (empty docs, doesn't feature a properly setup table). Nevertheless, I would love to hear your feedback if you try it out, especially if you use collaborative notes/docs today and have opinions on what they’re missing!

Broomsday: https://broomsday.com sends folks emails and SMS the night before street sweeping parking restrictions for their block(s). Email notifications are free, SMS on a paid season pass. The schedule here is block-by-block and easy to forget, so people get ticketed _a lot_ at $50 a pop. The city has an email-only notification service that's free, but it's poorly supported and the interface sucks. This is ready; I'm testing with friends and family currently before attempting real marketing.

HailPass: https://hailpass.com similarly is a notify-before-pain service that integrates a bunch of open weather services (NWS/NOAA mostly, plus a handful of impact reporters and working on a small hail-specific ML model) to give folks on the Front Range 5-10m heads-up before damaging hail arrives at their location. Weather prediction is (not shocking) hard so I'm still tuning to get as much signal out of the noise as possible; some false alarms will be unavoidable but I want to cut them down before even a F&F release. This year's season is pretty much over with, so aiming for an April '27 release.

There's a lot of ski/snowboard/winter sport culture here, but there's also existing services for those, and I'm mostly trying to offer new coverage where there isn't a good option for my neighbors. Might do an ash borer treatment/prevention service navigator yet.

None of this is going to make me wealthy or famous, but building things that help the people that I actually interact with every day and that are a part of a community that supports my family feels _really_ good.

Rides Claude Code/Codex hooks and captures useful information, and injects it at need (like when there's an error) for other agents. It works across your team then at a global marketplace layer, so there's incentives for people to contribute.

We're in the process of benchmarking and we are aiming for 10% in token reductions. If any team is interested, we're accepting preliminary design partners and can get you started with the benefits.

Also: kids can code using cardboard cut-out blocks and just take a photo to import, generate Arduino firmware, compile and flash to ESP32 - all from a single docker web application.

Hoping to bootstrap a cheaper, open source alternative to current systems (one of which my son is using at his school). I have had success doing this with another project on Patreon so that's where it is going to be launched. https://www.patreon.com/ChonkyBlox - so far just a couple of demo video's but code will be released in full once I have added more blocks and a tutorial.

Ultimately this is aimed at the South African education sector, where many schools may have only one computer available for a classroom to share, hence the cardboard cut-outs. There is also a hardware component still in development - a simple pcb breadboard break-out with connectors for components instead of kids having to use jumper cables on the breadboared. We also have a working Desktop application which does code assistance from within the Arduino IDE - using the same web server with api, so literally everything from very small kids to advanced is covered.

Desperately trying to attract new monthly sponsors and people willing to buy me the occasional pizza with my terrible HTML skills. Is it working?

If any individuals, companies (or bitcoin millionaires) would like to help a long-time OpenBSD slacker, unslack, I'd really like to focus more of my time on open source development (and advocacy), rather than making rent. Feel free to contact me.

https://brynet.ca/wallofpizza.html

(Native SegWit): bc1qwe6zv0ezq4gzlea6tw45qhsn5kckheljn0krvt

I’m spending like $25/mo at least in GHA minutes.

Then working on securing and tinkering with my homelab. And little utilities that make repeated deterministic functions easier for me and agents.

[1] https://github.com/jha-naman/treetags

[2] https://github.com/jha-naman/treetags/pull/62

Tried to use a generator for automating the bulk of the scanner for a language from `grammar.json` file of a tree-sitter grammar. A runtime engine uses the scanner for a forward only walk on the scanned code and calls the hooks to generate tags.

[3] https://github.com/jha-naman/treetags/pull/56

A complicated mess of a generator that takes a few declarative inputs and tries to generate code for spitting out tags for a given language.

It's a CD tool for Kubernetes built on top of Flux and OpenKruise canary controller to bring a full-featured end to end delivery on Kubernetes over multiple environments in a declarative way without the pipelines.

I wanted to stop reinventing the wheel with pipeline engines every time I needed to deploy something. Every stage of the delivery is just a composable component (health checks, smoke tests, schedules, environment promotions, service dependencies).

I just released a new version recently that integrates with GitHub so one can track exactly what's deployed where and how far your change progressed.

https://smart-notes.xyz

The idea is to make an extension that allows you to flexibly fill out fields on your cards with AI generated text, speech, and images. Think generating example sentences for your entire deck, or adding furigana to kanji (small phonetic characters with a very delicate syntax). It works just as well for language learners as it does for medical students, etc.

The secondary goal has been to make this the most well designed, intuitive, and stable Anki extension in the world. I don’t think it’s there yet, but it’s on its way. It’s been very interesting to try to work out a design that affords the flexibility to generate anything for whatever you’re studying but remains approachable and discoverable to your marginal Anki user, many of whom are younger and have varying levels of English ability. Many interesting technical challenges as well.

Slowly building towards the Show HN post, but need a few more features. Connecting with and chatting with dedicated users in countries around the world over the last few years has made this the most gratifying thing I’ve ever built! It’s still at the scale that receiving support emails is fun and I can build relationships with power users and long term subscribers.

- When your agent is stuck on a bleeding edge issue, search Push Realm first for a solution. - If you find a solution, your agent can mark it as successful to help surface the solution to others (and hopefully save fruitlessly burning more tokens) - Can't find a solution? Post an open problem with your current investigation. Another agent may be able to solve the problem, and will have a head start thanks to your context - Solutions can be linked/edited/have addendum added by any agent, allowing complete, up-to-date solutions for a range of cutting edge issues

Finally getting around to organising my photo archive and setting up a metadata extraction pipeline that makes sense for me.

(At the day job, curious about adapting app layouts to accommodate the iPhone Duo and address the various Android foldables at the same time, too).

I find Grasshopper, especially its data model, ideal for a certain type of algorithmic art/design, and have always wanted to use it in a 2D graphics package.

https://www.figma.com/community/plugin/1677548868352947603/c...

It has proven surprisingly resistant to AI so far - Astra can make a very quick prototype but upon review it had many defects. I have had to guide it very thoroughly to find all the random solver bugs (bad conditioning, formulation, bugs in openscvx which I had originally had the AI port to rust, etc.) preventing well-behaved solves. But I think (hope?) I have turned the corner on these.

This will enable some very interesting further experiments: full mission planning, Falcon-9-style ascent with split control, vehicle swarms, etc.

You can track what you’re reading, keep notes and reflections, see your reading stats, build out your bookshelf, and a bunch more. Over 4k monthly active users.

Been building it solo & adding features based on what readers ask for.

https://pickupreader.com

My wife and I are working on a math/science/CS-inspired jewelry: pieces that stand on their own aesthetically but have a hidden meaning.

We currently have two styles: lambda calculus based pieces (we depict the Tromp diagram) where we have Y-Combinator earrings (well, strictly speaking they are one beta reduction away from Y-combinator. Aesthetic oblige) and a pendant depicting a lambda expression computing Graham's number. The other style is quantum computing circuits, based on quantum computing research my brother (a physics professor) is doing: a pendant that is actually a non-local controlled-NOT gate.

I wrote a tiny DSL to describe the jewelry pieces, and an interpreter to produce CAD files. We then either 3D print them or have them produced by lost-wax.

We have our pieces in consignent in a jewelry store, and are working to put them in a museum store.

Marketing is the hardest part. Ideas are welcome.

https://yups.io

The "official" syntaxis is

https://yups.io/?url=https://twitter.com/Wikipedia

But it is very flexible to manage errors

https://yups.io/www.instagram.com/reel/DdOFgxdlMjv/?stkn=MWR...

The android app is in beta now and the iOS app is in development.

https://keelcoaching.app/

*walletwallet.dev

1) https://git.koehr.ing/n/solace

- I've been tweaking a bot that I built to doomscroll job boards for me, to recycle more parsing logic between target sites. It turns out that, much of the time, I can cut down on DOM-based scraping a lot by just parsing schema.org-based JSON-LD. Also casually researching vanilla Web components, view transitions, and Signals in a general effort to make the whole thing less framework-heavy. (Plus it will have side benefits to building the crawlers to have a better understanding of light vs shadow DOM.) Eventually I need to get to figuring out how I want to handle distributing this local-first app across multiple clients... I've been putting that off for a while, but it kind of crosses over with the JSON-LD thing, in that (even more than it did before I found this) it also just makes a lot of sense to use a browser extension to collect potential matches passively.

- 3D printing experiments. I got a used SV06+ a few months ago that turned out to be a lot more finicky than is suited to a first time user... but that was in the course of trying for several months to make plans with a friend that was getting rid of her Ender -- which I then managed to resurrect using all the cleaning tools and tinkering research that I put into my fussier machine. I've since been toying around with a lot of different ideas on how to clean up my workspace and/or fix/reuse stuff I have already (parts trays, Skadis panels, a case for an old Framework mainboard, various instrument stands...) and also toying around on paper with what kinds of printed items I might be able to sell.

- Starting on cleaning up a basement that resembles the Research floor from Control. Also a use for the printer, because if I can just print cheap tools out of PLA then I don't have to care about possibly needing to sacrifice them to the mold.

- Various Coursera stuff. My state has some partnership with Google for "AI readiness" training, that grossly undersells the various other adjacent topics offered, ranging from cybersecurity to marketing and eCommerce. Stuff where it may be a relevant topic at points, but isn't the subject matter.

It's based on the Server-Driven UI philosophy where the backend streams both code and UI into a frontend that just knows how to render what it's told. This is pretty cool because it makes it makes over-the-air updates possible.

It also follows the batteries-included philosophy of Rails. Has an ORM, background and cron jobs (all based on Postgres), Django-style migrations, JSX Emails and pretty great FFI that's built around a simple `"use native"` directive, in the React Server Component fashion).

I had a bunch of extra Fable credits, so I spent about $10k running autoresearch loops on 200 of the top github repos with frontends to try and speed up the frontend performance. I distilled them down into a leaderboard of the most common wins, and built out an autoresearch loop that takes those learnings and applies them to your repo.

Works with your existing claude/cursor/codex sub in a cute custom TUI.

I just submitted a Show HN for it: https://news.ycombinator.com/item?id=49687032

Also created a fun simple "card game" activity for writers looking for story ideas or stuck with writers block: https://talemancy.com/

(This was somewhat inspired by memories of playing Ultima IV as a teenager)

Currently working on something a little more visually focused in creative design.

I don't like putting 20-30 agent skills in the .claude/skills/ dir and letting the agent figure it out. I keep all the skills I've created and adapted over time in a separate git repo and then from there I copy them to the project skill dir when i need them for a session and then remove them when I'm done.

This TUI just replaces all the manual work with ls, cp -r, and rm -rf commands with a few keystrokes.

[1] https://github.com/primaprashant/sei

https://www.patreon.com/MickeyvanOlst/posts/meet-aml-macos-1...

Typically TD for the Mac has always been a bit underserved, by leaning into some of the frameworks that exclusively exist on macOS I'm hoping more people will see it as a viable platform for this kind of stuff.

A new UI library made with zero dependencies (native web components). I just made it public as I actually use it for my personal projects since past year.

The core principle is to help with UI development without bloating a project. It works with vue/nuxt (tested, my projects are done with it), but also react/angular/svelte/etc.

One feedback I got from reddit (I published it this week there) is that AGPLv3 may be a problem for adoption... still not sure if should I use MIT.

If either of those are interesting to you, please reach out!

For example, I am helping some restaurants learn exactly how much each item on the menu costs, what the margins are, and how much profit each dish is bringing in because I integrate with their PoS system.

https://imgur.com/a/C127GOY

It's all a part of GetSetReply which is turning into a small suite of tools for SMBs

https://GetSetReply.com

https://beacio.com

so yeah.. it builds the stories out of their actual life. their family and friends are in the cast, their dog, the thing they're nervous about this week. the kid doesn't just appear in the story, the story is about their world and imagination and grows with them.

ultimate goal is to keep iterating and get to a level of quality of Bluey, etc but have it actually be the kids world with agency/choices vs. one they have to passively sit back and watch, and that they're not in.

would love any feedback. i know there's been others like Ello shared on here and those threads were really interesting to know HN's opinion on. this does not take an educational and instructional approach. Tella is meant to help develop who they are through stories and be a better screen alternative time to the rest of the algo/curated garbage out there. anyway you guys are a critical and technical bunch and i respect/appreciate that.. especially since this of course leverages multiple AI services to create the stories ~

https://tella.kids/

https://dstld.news - I have always wanted a personalized news site so I built one using a few news APIs with AI summaries.

https://hn.wreet.xyz - I'm a big fan of skeleton.dev and wanted a HN frontend with all the fun themes.

Nothing too exciting, just trying to find the joy in making again.

I don't even know what that means.

https://raygum.com

Each week I research one part of retention, teach it, and apply it to two real-world products I built.

I’ve published five lectures so far, and think the series should be useful to anyone here building a product: https://www.youtube.com/playlist?list=PLFp5nmjrQeug

I was curious about formats more efficient for agent communication than JSON and also proving if the framework I curated could handle the load and traffic.

It's been really fun to observe.

https://dfwfractionalfde.com

I'll continue working on improvements aiming at the first stable release by the end of this year hopefully.

https://emojistime.com

If you love catching up on highlights, check https://thepelota.tv/

It’s like Netflix but for soccer highlights, with all the major leagues in one place as soon as they are available on YouTube, all free and no ads.

Don helps you set goals.

Don reminds you to take breaks.

Don checks in how you fell.

Don judges you when you go off track.

Don celebrates you when you get stuff done.

https://donethat.ai/solutions/productivity

Looking for feedback from people who already run Claude Code and are testing out new AI software factories or tools.

Try it here https://github.com/Team1-dev/Team1-Factory

Please only run this on a VPS or isolated environment and not on your personal machine as it runs with full permissions.

Here's the skill: https://github.com/gavmor/x86-cpp-reversing-skill

It's all slop, but it's battle-tested and producing results. It's quite fun and inspiring to see some of these assets like textures and geometry that are improperly decompiled, bit shifted or something like that. produces a lot of abstract, glitchy art.

To make sure that my process and results are reproducible, I've gotten back into maintaining Concourse CI pipelines. They were very useful when we were shipping a fork of k8s for VMware, and now they are a fun way of shipping cyberpunk billboard sprites to Cloudflare buckets.

I got back into Concourse in order to attempt a more rigorous approach to generative AI experimentation as well. Unfortunately, there are just so many odd techniques, configurations, loras, and utilities striking my fancy that my experiment pipelines have exploded into the dozens, and Concourse is not a large enough or a high-level enough organizing principle.

And then ... well, we'll see. I'm also reading a lot of books and stuff on neuroscience, neuromorphic computing[3], analog computing, etc. I don't have some "grand unified theory" or anything, just playing around in this space.

There's a lot more I could say about this, but I'll save that for a blog post or something. That said, if anybody wants to see some pictures and read some write-ups of some of this stuff, add me on LinkedIn[4] and you'll see some of that stuff in my activity there.

EDIT:

What the heck, here's a picture for anybody who's interested.

https://fogbeam.com/images/scope_20260913_202613.png

The magenta trace is the "spike train" which is output from a Rigol DG4162 Function Generator. The yellow trace is the voltage at the anode of the PUT, which simulates the "action potential" of the neuron membrane. And the cyan trace is the cathode of the PUT, which simulates the output of the neuron. What we see here are several input pulses hitting, with each bumping the action potential up a little, until it finally hits a threshold and then "fires" and resets. Lather rinse repeat.

[1]: https://en.wikipedia.org/wiki/Programmable_unijunction_trans...

[2]: https://neuronaldynamics.epfl.ch/online/Ch1.S3.html

[3]: https://en.wikipedia.org/wiki/Neuromorphic_computing

[4]: https://www.linkedin.com/in/philliprhodes/

https://optimem.org

1. Aetheris: geometry CAD kernel, https://github.com/yuechen-li-dev/Aetheris/.

Full code CAD capability with big coverage already and some functionalities that even OpenCascade/Parasolid/ACIS doesn't have, full sheet metal module, programmable part assembly, analytical fillets/chamfers, mathematical knots, auto-route for piping, built-in finite element analysis, etc. Had Astra make an improved version of the V8 demo that was going around on LinkedIn, so it can do general hard surface modeling pretty well too, turn all the Astra demo prowess into reusable capabilities/templates. The DSL is human writable too, so give it a try if you want. https://aetheris-editable-v8.yuechenli.workers.dev/

2. Concept language: https://github.com/yuechen-li-dev/Concept

I've said before that Carbon isn't a real programming language, never mind a successor to C++, so I decided to put my money where my mouth is. The idea of it is to be more TypeScript to C++'s JavaScript and to generalize C++20 concepts from template constraints to what C++26 is doing with contracts, and bring the equivalent of Rust's borrow checker to be opt-in by default instead of opt-out, fast compile time, in a syntax that C++ users are already familiar with (`const auto` instead of `let` for example) as well as templates and comptime. Language is done-ish, not self hosted yet, still compiles to C11, kernel and allocator libraries are finished, currently working on the scheduler right now.

3. Copeland TS, https://github.com/yuechen-li-dev/copeland

TypeScript for .NET without all the weirdness of Javascript, with full Nuget and NPM inter-op, Rust style exhaustive `match`, templates, etc. It's actually weird how much cleaned up TypeScript ended up looking like cleaned up C++. Compiles to JS, C#, WASM via Blazor WebAssembly, and SPIR-V via HLSL/DXC, and runs on V8 for JS and RyuJIT/NativeAOT for C#. The conclusion is that RyuJIT ended up being ~2x faster than V8 JS in hot loops but the cold startup time is higher, so replacing JS for UI really isn't worth it. Comes with full UI layout system, Vulkan renderer, and game/app runtime, but those are still pretty rough.

https://allthedamn.tools

I created https://getnoloop.com to block the feed on iOS

and... whenever i have some spare gpt-6 astra left i am working on a R.U.S.E reimplementation alongside some other threejs experiments

https://picobble.com/

Not like I'm gonna anything much with it, just was fun to get something nice-looking and presentable up for once. Working on polishing more of them and, of course, designing new ones.

2) A font generation system, inspired by Iosevka, albeit much much simpler. Learning tons of interesting technical things about TTF and WOFF2.

https://sfw.tools

If there's a tool you'd like to see there, let me know and I'll add it.

I'm thinking about buying all the strains and pushing them through my automated sequencing pipeline, and building a yeast genotype -> flavor converter. Then, I think it'd be neat if you could have someone try a bunch of wines to get their favorite, and then genetically engineer a yeast strain specifically for their favorite flavors. Think that could be neat.

https://nittanynights.com/

https://indyafterfive.com/

I wrote my own site parsing toolkit which removed the friction I have with the current ones. It's now easy to add new locations quickly to scale.