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

I'm currently working on modeling energy, climate and new policies like universal basic income

https://microlandia.city

https://tiledwords.com

I checked my analytics recently and over 100 people have 100+ day streaks which kind of blows my mind!

I released custom player puzzles which has been a lot of fun! I’ve gotten dozens of submissions that I’m working through. People are submitting really clever and interesting puzzles. It’s fun to get to solve puzzles I didn’t make myself! There’s more I want to do here (featured puzzles, categories, etc.)

https://tiledwords.com/player-puzzles/page/1

I think I’ve also tracked down an issue that was causing the game to crash on older iPhones. I’m having playtesters run through it now and hope to deploy tomorrow. (Switching some positioning rules from CSS transforms to SVG coordinates)

I recently made some puzzle brainstorming tools using the Datamuse API which have been very helpful for brainstorming words related to a theme.

I’m starting to debate some monetized features. So far everything is free but it would be nice if my wife and I could dedicate more time to this. If I could get a few thousand dollars a month in subscriptions my wife could quit her job and focus more on puzzle creation and improving the game. If you play and have ideas for features you pay for I’d love to hear them!

I've really enjoyed the journey of 3D printing and being able to create all kinds of mechanically useful things over the last few years, but I had always wanted to go even further and incorporate some non-trivial custom electronics.

For this project I had a space constraint for the motor controller board, so while I could have probably hacked together a working perfboard, it just wasn't going to be satisfying. So I finally took the plunge and spent 40 or so hours in KiCad learning how read IC reference documents, picking components, and of course, doing the PCB trace layout.

It's really just a 12v→5v buck circuit, all the plumbing and ancillary components for connecting a ESP32 module to a couple motor driver ICs, and some headers, but it is completely mine!

Just got 5 of my boards in the mail from JLCPCB the other day (insane turnaround, less than a week) and was very happy to find that the entire circuit worked perfectly! I did spend a fair amount of time going over the design with Claude though, so I think that paid off (the kicad files are plaintext, so it made easy work of understanding what I was doing).

Still putting together the repo here, but I'm hoping to make a little blog post out of the project too :) https://github.com/evanpurkhiser/HOPPVALS-MRF-01

After 1.5 years of development and two exhausting pivots, I’m incredibly happy to finally have our v1 live!

While most of the HR tech is rushing to use black-box AI, I built the exact opposite. It's a transparent, math-driven fitness engine. It extracts objective data from CVs and calculates how well applicants match requirements, letting you see the reasoning behind why someone scored an X%.

If anyone here builds in the HR space or regularly hires engineers, I would absolutely love your feedback or a roast of the landing page.

PS This is a project of immense importance for me, I've been working on for past ~2 years, I'd appreciate to know why this comment is flagged.

The pitch: It's insane that we have to pull in Python or Lua to build C code. CMake is an abomination against god that has become usable in spite of itself. Zig cc is proof that this entire ecosystem is an embarrassment. My tool gives C projects a TOML manifest, and builds scripts written in C and JIT compiled by the tool. Now, you can write build scripts in the language itself, pull in dependencies you wanted to use anyway.

It also provides a stable ABI. There's an HTTP-backed index and a Git-backed index. And it generally does the same thing for C that, say, Bun did for JS/TS. You'll be able to run C files from source and have the entire ecosystem available. You'll be able to trivially generate single file static binaries, or dynamically link to an older glibc without arcane tricks. It will fix C.

I'm also still working on my "what if we wrote a real standard library for C"; I added some feedback I got from the release.

https://github.com/tspader/sp

https://breaka.club/blog/why-were-building-clubs-for-kids

We also teach kids visual scripting in Overcooked 2!, allowing kids to code their way through the levels of an existing much beloved game:

https://youtu.be/ITWSL5lTLig

I'm running an in school pilot this week (Lunch time school club).

The tech stack for the main product is honestly pretty intense at this point with full multiplayer support, offline play, transitioning from client authoritative to joining a remote server. Built atop GodotJS, TypeScript bindings for Godot, which I maintain. Huge monorepo with over a million lines (yes, I'm aware that's NOT a good thing), and GodotJS itself is not included in that.

We try to create pieces that stand on their own aesthetically but have a hidden meaning. We currently have two styles: lambda calculus based pieces (we depict the lambda/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 are 200% out of our comfort zone (and love it): I know nothing of front end dev, payments, or anything like that. The diamond district in New York is a neighborhood we normally actively avoid, but if you are forced to go there it is fascinating (people examining diamonds on the corner of the street, others in fur coats in summer straight out of a mafia movie...), and especial marketing. Jewelry is a completely saturated business (luckily we are not doing this to pay the rent); we think we have a unique angle, but we are still figuring out the target audience (if there is one).

Store: https://studio-galois.com/

We're a collaborative canvas + context engine for all the code and docs in your company, with a zoomable UI + CLI , where you can collaborate with your co-workers and agents.

We map technical debt, agent readiness, code complexity, security scanning, bus factor and more, so you can easily see how all the software in your company runs.

One of the most complex things is our incremental git blame engine built on top of GitOxide, as our backend is fully built on Rust. Our frontend is built on PixiJS so you can explore at gaming speed with 60Hz refresh rates.

Recently we sponsored Rust Week in Europe and a hundred or so developers tried our mini-game which is GeoGuessr for code, and got rave reviews. Future is looking bright!

The Tatras may look solid from the outside, but our mountains are hollow inside - and there is still a lot to discover. The project brings together cave survey data, entrances, maps, and terrain models into one open spatial dataset.

3D model: https://dlubom.github.io/Jaskiniowy-Kataster-Tatr-Zachodnich...

Repo: https://github.com/dlubom/Jaskiniowy-Kataster-Tatr-Zachodnic...

Feedback is welcome, especially from people interested in cave mapping, GIS, open scientific datasets, or underground worlds in general.

Don't tell my husband that I spent more than $200 on parts and supplies for it.

I've wanted a Heathkit since I learned about them as a teenager, and this is the first one I've ever seen in the wild. The original owner left the date he assembled it and his callsign written on the inside! I looked him up and he died in 2013, but by sheer happenstance I'm restoring it 58 years to the day that he initially built it. I got super lucky with this unit because as far as I can tell, it's only been run a few hours in its entire life. I really only have to replace aged components because they're physically breaking down, I expect the thing will outlive me once I'm done with it. Can't wait to hand it off to a bewildered young EE in another half century.

It’s basically a one-to-many phone call that only one person can answer. Send a beacon to a group, and everyone gets rung at the same time. The first person who answers gets connected for a 1-1 call, and for everyone else the signal drops silently. No missed-calls or pressure to answer. Works pretty well given most people keep their phones on silent (and there are in-app settings for quiet hours too).

iOS/TestFlight only for now. It works best if you're able to join with at least four people you don't speak with as much as you'd like. I have a couple dozen connections on the app now, and it feels like magic to me. Would love feedback from both introverts and extroverts who still like phone calls, or wish they had more of them:

https://trybeacon.chat/

Android coming soon!

I've got a little bit of mobility back in my wrist now (enough to type on a standard layout keyboard), so I gave the new split keyboard a try, and the switch was less than smooth to say the least. I looked online for different resources to learn mainly just the Colemak layout, and while each had their strengths, they didn't all do what I wanted.

To that end, and because I don't have the time or wrist at the moment, I vibe coded a desktop program that merges aspects of MonkeyType, Keyzen-Colemak and Colemak Academy. Mainly to give myself a tool to learn with, but also to see how useful vibe coding something from scratch like this is. So far I've been impressed with how far it got on the first go. Only a few times have I needed to guide it to fix behaviors, but most of my time has been spent extending the program in ways that make it more useful to me.

Once I've got the ability to, I might consider giving a rewrite of this tool a go by my own hands. I haven't looked at the code it's produced, but I'm sure there will be aspects of it that I would prefer be done differently.

My wife and I continue to work on Uruky [1], a simpler Kagi alternative, based in the EU.

Last month we launched image search (got out of beta this month), added our own index and crawler (via Uruky Site Search [2]), and reached 100 monthly active accounts (we’ve passed 150 now)! You can also see a privacy-focused independent blogger wrote about us [3]!!

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

You can also now get a free trial for 2 hours when you signup if you pass a proof-of-work captcha (another suggestion made here on HN, and it uses a local Altcha).

Our main challenge continues to be discoverability and outreach because we want to do it ethically. Ideas are welcome! We’ve been sponsoring open source projects, open source maintainers, and indie, small-web, and privacy-related websites and applications.

Feature-wise, for June we’ve already added a ton of personalization and privacy-increasing features like URL rewrites, cash-by-mail payments, and anonymous vouchers! Upcoming is partnering with ProxyStore to sell vouchers (we’re currently in talks for this), so you can buy vouchers with XMR/Monero or other cryptocurrencies. Then we’ll be looking into increasing our own index, focused on indie/small web.

Thank you for your kindness!

[1]: https://uruky.com

[2]: https://uruky.com/site-search

[3]: https://theprivacydad.com/interview-with-the-engineer-of-uru...

Reading Brand's quick little life changer kept me going with surprisingly few cuss fits:

The Maintenance of Everything: https://search.worldcat.org/title/1511798465

Thanks, Stew!

One of the hardest parts I've found is the diarisation (who said what) side of things. Trying to tune this and have it working in a way that doesn't absolutely grind the laptop to a halt or take forever to complete has been _hard_ but also extremely rewarding.

Another part has been the fine tuning side of the Phi-4 model, I'm on version 10 now, getting that pipeline down was a journey in itself, but I've got some great results. I wrote a bit about it in a comment here - https://news.ycombinator.com/item?id=48385906#48389625

I absolutely love working on this, I still wake up and the first thing I think about is voice transcription pipelines (sad I know), but I'm excited to see how much further performance and utility I can squeeze out.

https://thepublictab.com/ https://tryfinn.ai/ https://travelerscodex.com/ https://github.com/govapi-rb https://chamomile-rb.github.io/ https://houseguessr.io/

The HN Arcade continues chugging along https://hnarcade.com

We now have over 150+ games!

Im also working on an ASO tool AppStoreSearch or AppsToResearch :)

https://appstoresearch.grahamyooll.com

Still early days. Im making it as I have a couple of friends who were not so thrilled with the tools out there specifically for the app store. They mentioned how important it was to their income to track the positioning of their apps on stores. If their app dropped to #2, that would be a huge hit to their income.

Happy to have any feedback - but its far from complete

Also recently got a lot of home VHS tapes digitalized and always had trouble with playing from Google drive or finding the right video. So I just built a webapp this month to split the videos into clips, transcoding it for better streaming, Google casting support, and tagging for search. [1]

[0]: https://upkeepnest.com [1]: https://heirloomreel.com

Right now there is a runtime and compiler targeting C, written in dependency-free Rust, and a minimal Python frontend. The project is very much proof-of-concept stage so not yet fast. Working on a CUDA backend now.

The goal is to enable automatic discovery of FlashAttention-style optimizations which is not feasible with current compilers.

Very open to feedback/discussion from anybody interested in or knowledgeable about tensor compilers!

repo: https://github.com/ilang-dev/i

There is a couple of semi-unique features; you can use your voice to dictate and generate events (feeding, sleep etc), you can also scan documents for growth measurements.

You don't need user account to use it, there is no subscription, the paid features are available behind a single purchase for lifetime. Still, like 90% of the features are available for free.

Also https://www.athilio.com/ privacy focused, highly customisable personal data analytics for your Oura, Garmin, Polar and Apple Health (ios port coming soon). Of course there is couple of AI features (with a single switch to turn all off), originally those were built just so I would learn how to embed agents in sw products myself. The whole app was originally built for personal use to fix missing features in the manufacturers own platforms: - Period over period comparisons (this month vs this month last year) - Comparing different metrics - Customizable graphs and other widgets - And of course combining the manufacturers metrics (oura for sleep, garmin for training etc etc) Existing solutions for this kind of software seem to have focus on social (strava), or coaching (training peaks), or they are just straight up crazy expensive with their paid tier (both tp and strava for example).

Mostly I wanted more art and colour in my workday - something to look at, learn through and draw inspiration from in the moments between meetings and code. You can create an account to save your favourites and curate your own gallery. Just released collections that you can make public.

Art from: The Metropolitan Museum of Art. Art Institute of Chicago. Rijksmuseum. Cleveland Museum of Art.

In April I started playing round with generating a semi-automated pipeline with python and Claude to generate a private podcast that does a deep dive into AI research papers. I think it is really cool. It fetches papers, scores them based on novelty, importance, relevancy, etc., and then writes the podcast script. It then generates the show by using Eleven Labs voices and then puts it in an RSS feed that Apple Podcasts is ok with.

My personal expense for generating this stuff is a sunk cost, so in May I opened it to everyone via https://paperdive.ai/ It was really fun working with Claude 4.7, 4.8 and even Fable 5, to make the site and refine the pipeline. Now I put out about 4-5 episodes a day. I listen to each one first, then promote the "staged" episodes to my "prod" feed.

This weekend I just add weekly and monthly reviews. Claude will write the review and another instance will generate a script the converts the review into something (hopefully) easier to listen to.

Here is last week: https://paperdive.ai/review/weekly-2026-06-14.html And here is the review for May: https://paperdive.ai/review/monthly-2026-05.html

Now, during my commute, I listen to the individual episodes and the reviews - I typically run them at 1.5x to 2x speed. I have become a much better user of the AI tools by keeping up with recent research.

Most recently I was also probing people about how they conceptualize of the soul, making my own drawings, and asking others for drawings. If you have a few minutes I would also be interested in seeing how you would draw a soul, given pen and paper or equivalent materials. It often feels like for a lot of people the concept of the soul gets comingled with very confusing definitions.

There's a general problem where certain concepts become so overloaded that just disambiguating and clarifying what is meant becomes a challenge. I will note that if your first thought or question is whether the soul is even real, you might be confused about the definition or we might be referring to different concepts.

---

https://github.com/hill/lazyslurm - a terminal ui for SLURM jobs (like lazygit but for slurm!)

---

https://github.com/hill/pg_tamagotchi - a tamagotchi that lives in your postgres instance (mainly to learn about pg extensions)

This was very much a passion project and an idea I’ve wanted to see alive for decades, and also let me explore some tech I wanted to get deeper on. I’m bullish on the the tighter integration of CPUs, GPU style cores, and shared memory. Our game, LocoMo, relies heavily of GPU processing of entities under the hood.

You can see me do a walkthrough of the current state of the game here: https://youtu.be/NbB0DCX8Pis?is=vGEw5oTMu_W9f-zT

https://onebusawaycloud.com/

It’s a project of the non-profit Open Transit Software Foundation that we’re using to fund our other initiatives, like bringing real-time transit information to billions of people around the world.

Since last month, I've added a layer of polish to the product, added support for deploying a SMS and phone gateway to realtime transit information, and built out the marketing website to include solutions pages for higher education, SMS, and more.

All of this depends on a bunch of really cool open source projects we’re building, like Maglev, a Golang server that can power realtime transit apps. Maglev is already being used in production, and you can set up a local install in about 15 minutes: https://opentransitsoftwarefoundation.org/2026/04/setting-up...

The other OSS projects we have include: building data products, iOS and Android apps, web apps, a Pebble watch app(!), and too many others to list. See them all here: https://github.com/onebusaway/

We’re always looking for volunteers, especially people outside of the engineering disciplines: https://ossvolunteers.com/organizations/open-transit-softwar...

I am so careful not to let anything not heavily encrypted touch a network request. Sync is opt-in, offline is default. This is very challenging for me, but I want to help her the best way I know: building software for humans.

It can tell you things like:

- The car that parked nearby last night coincided with a "Derek's Galaxy Buds" device with MAC address aa:bb:cc:dd:ee:ff. The buds also drove by briefly the previous night.

- Alert on sudden cross-specturm disturbance (e.g. burglars using a cheap jammer to disable WiFi cameras).

- Alert on known device contact loss (powered off / left premises).

- Review device movement across a campus/neighborhood (using multiple listening pods).

I have a working PoC. It can run on a cheap, low-power computer (e.g. Raspberry Pi) supporting multiple RF sensors (BT/BLE/WiFi). Has a web UI. Can publish events to an external security system. Currently working on an LLM interface to make it trivial for a non-technical operator to set policies and ask questions about events.

Could be sold as an appliance or a license for a DIY build.

Seed investors are welcome to contact rf-monitor@tuta.com

- Reenvision technologies: simple software. Local first - no added complexity. Infinite scale without having to add 100 front-end UI frameworks: simple Python, CSS, and JS with SQLite. The design is absolutely breathtaking and beautiful and it is built people first (let's worry about scale later).

- Simple LLM: an LLM which doesn't need a GPU to function. It uses Hebbian learning with extreme compression and attempts to achieve 'reasoning ability' through using a in-built Prolog interpreter. It very much resembles a human being in it's 'thinking mode' so far but still far from perfect.

- Simple-Education: local first software for parents looking to provide home-schooling for their children. It makes learning easy and fun and uses best practices to maximise your child's chance of success.

- About a dozen other projects which I've started but I need help on. If you want to team up -- I will give you equal equity in my start-ups. I cannot offer you a salary though I'm not at the point yet where I can do that: but I will give you equal equity in anything that you want to work on together with me. I have over 100 different million dollar ideas that will make us wealthy if you want to join my team, so PM me if you're interested.

The thing Im most proud of though is just the viewer, its designed to just open all the images and videos in a folder, and then there is no UI except a right click context menu, the list is a grid or a masonry layout that uses 100% of the space for the images/video so you can just navigate them. It adds anything you open to a local sqlite db so you can tag things if you want optionally. Also control modes that make sense for either a mouse or a laptop trackpad.

After my experience in consulting museums, I found that they spend a lot of money on software, which could potentially be replaced with open source software. Therefore I started an awesome list with FOSS software for museums: https://github.com/smartcompanion-app/awesome-open-source-mu....

Repo is here if anyone wants to have a look: https://github.com/deosjr/unreal-talk

And a browser-based version can be found here: https://deosjr.github.io/dynamicland/live

I also made Computer Engineering for Babies which I've posted about on here a couple times before.

https://hackylabs.com

- A WS + WebRTC mesh

- A request/response protocol incentivizing the closest or most efficient peers to respond to requests

- A WASM environment ensuring deterministic execution and supporting contract composition

- Collateralization around responses, ensuring invalid responses have amortized negative value

- A consensus and UTXO layer, focused on low-latency, low-finality micropayments (for request incentive and collateral), using WASM compute as the weight metric

The idea came out of me wondering a few years ago why a multiplayer game couldn't simply be run on the player's machines without a central server. It has grown since, but the focus has remained on low-latency and log(N) state consensus (unlike a blockchain).

It's wrapped up as a single fetch() method, mostly mirroring the browser's native fetch(). There's a lot more I could say; I love working on it and discovering elegant solutions to the problems that pop up. I'm hoping to release a prototype in a few weeks/months. If you're interested in trying it out, let me know (joel at scaffold.io); I'd love to have some other eyes on it.

I've been pleasantly surprised at the community beginning to get excited about the game.

I initially created this to work with the MCP servers as I needed OAuth to work locally and go through UI -> backend -> MCP client.

I add some features to this every now and then. Would like to have some other users for same :)

https://www.agentkanban.io - Github Copilot / Claude Code integrated Kanban board with context management

https://www.asmusictheory.com - Music Theory lessons, tools, including piano roll with midi in the web browser

Con Edison keeps getting so stupidly expensive that I decided to use my backyard for reasons other than generating weeds that I have to pay someone to remove, and instead decided to set up an off grid solar in my backyard. I bought an Aferiy P310, learned how to use a few tools to drill some holes in my bricks, and set up a bunch of Home Assistant automations, and now my basement and living room is powered by nuclear fusion with an eight minute delivery time.

Of course, now that I'm babysitting a Home Assistant instance, I felt like I should use it; Google is completely and totally incompetent with any of the "smart" devices, to a point where I swore an oath in blood that I will not buy anything Google Home or Nest related ever again. I've been replacing my awful Nest lock and awful Google thermostat with Matter-compatible stuff to work with Home Assistant.

I have been having Claude port an old game to WASM. I'm sadly not quite yet at liberty to discuss the intimate details on it (since it is not my game), though hopefully that will change soon.

Unlike a few other things I've automatically gotten ported to WASM [1] [2], this one has proven to be a lot more difficult and required a bit more active labor on my end. It was written using a strange combination of C++ and Java, with some JNI glue written in a way that neither I nor Claude are very familiar with.

It's been pretty fun figuring out how to get CheerpJ and Emscripten playing together, and it's been fun to actually write code and still be a little smarter than AI at it.

[1] https://showbo.at/3dmovie

[2] https://abuse-wasm.pages.dev/

Womb.FM - https://www.womb.fm

I discovered this week, while the paper was being reviewed by SG1, that I've accidentally stumbled into tackling a rather important problem. Senders as shipped in C++26 can really only express the async equivalent of inline functions because, except for `task`, all the standard senders fully encode the shape of their computation in their type. With something like the `function` I'm proposing, you can use senders to express async algorithms that are separately compiled, just like sync functions.

If the feature lands in a shape similar to what I've proposed in P4223R0, then I think an obvious extension is to modify the core language to support a newer kind of "coroutine" that allows you to define a sender with imperative code. My vision here is that we act on the observation that `std::execution` is a language feature implemented in the library by teaching the compiler how to turn imperative C++ with `co_await`s sprinkled through it into the corresponding sender and operation state. I think this would open the door to putting async object lifetime analysis and optimization where it belongs (in the compiler) without the overheads and inconveniences of C++20 coroutines. It would even let us apply the inliner to async functions when the compiler can see the body of an async callee, not just its declaration.

For now, my next step is to write P4223R1 to incorporate feedback from this past week's WG21 meeting, and continue exploring the design space around specifying sender attributes for a `function`—I'm thinking the current approach of specifying query function signatures needs to be replaced with a key-value object like receiver environments, but I'm not sure yet what consequences that change would have on the design.

In the last month, I have added support for more ERC rules (pin type compatibility checks), added initial support for net classes and also cleaned up the language a little (backslash line continuation, similar to python).

Recently, I just completed a 161-LED charlieplexed array design that uses nested for-loops to simplify the array design. It is currently in production and I plan to write a blog post soon to document this design.

As always, the motivation for creating Circuitscript is to describe schematics in terms of code rather than graphical UIs after using different CAD packages extensively (Allegro, Altium, KiCad) for work in the past. I wanted to spend more time thinking about the design itself rather than fiddling around with GUIs. With code, the design intentions become explicit and reviewable.

Feedback welcome, especially from anyone else frustrated with graphical schematic tools! If you have a KiCad design that you would like to convert to Circuitscript, please reach out to me as well and I will help you to do so as I am trying to challenge/test the limits of Circuitscript.

Lets you explore, filter, and rank locations (ZIP/counties/tracts) in the US to find places to move to and/or invest in. ~470 attributes with tons of customization (e.g., distance to work or the nearest hospital) and a ton of custom attributes (so it's not just an ACS viewer :-) ).

Based on a prototype/real need I had when I purchased my current house. Generic "Top 10 ZIP codes" aren't all that helpful (unless you fit that exact niche) and existing tools were either hyper focused on institutional investors (that want to build a subdivison whether it makes sense to live there or not), unaffordable, or both.

Since it's HN, stack is React/MapLibre/go backend + tile cache, data work is done largely in DuckDB.

https://stravaeger.com/

It's all vanilla Javascript, running in the browser, so you can wreck today's productivity right this minute if you like. It has multiplayer support, so I'll stand up a server in case anybody wants to jump in.

However what happens when you actually build and launch your agent is customers try it, do some initial runs and then go ask your manager to automate their use case. That is why I have been building https://toolscaled.com/ The goal being work through your problem space using agentic chat (like Claude Desktop) and then at the end convert it to a workflow. I am pretty close to launching and have been testing. If you're interested send me an email! (if you do sign up just fyi its still in beta so YMMV.

The fun part lately has been MyLLMos: the assistant builds HTML/Python apps on the fly, and you keep the ones you like in a gallery to re-run. It's slowly becoming a home screen for things your AI made for you. There's also an app marketplace, it's all free and open, HTML5 based, can be edited in the app or you can get the like of 'Fable' to generate an advance code and the app will happily store it and run it on your iPhone.

https://www.opticell-limited.com/myllm-os

It creates its own copy of your workdir for the agent to play in, and then you pull changes out ala git diffs or commits.

    $ yoloai new mybugfix . -a # launch default sandbox in . and also attach the terminal

    # Work with the agent...

    $ yoloai diff mybugfix  # See what it did
    $ yoloai apply mybugfix # Bring out commits and/or uncommitted changes.
    $ yoloai destroy mybugfix

Then, I will slap an ESP32 & z-wave on it :D secretly to feed my Home Assistant. :D

You can find the tool at https://www.cangjieworkbook.com/ and there is a free demo linked inside. It should work on desktop and mobile web browsers.

It's a project I have been working on for quite a long time and I released it on TestFlight about a week ago. It was really nice to work on something end-to-end, from creating a wrapper around llama.cpp with support for prompt caching/forking and automatic model loading and unloading based on device memory constraints, to the custom agentic harness the app runs on. I have also spent quite a lot of time on agent execution modes that I hope can enable to more easily reason about agent security regarding prompt injection attacks.

What I'm really hoping for now is to get actual feedback, to know if users end up having real use cases where the app is truly useful / interesting for them, to understand what should most urgently be improved etc.

https://bilembi.app/

[0] https://github.com/deepclause/deepclause-sdk

Recently started some agentic features for paid version, and this lead to a side project https://eatmydata.ai - a question-to-sql-to-dashboard builder, where data doesn't get exposed to AI (with bundled in-browser SQLite vector search, NER and many other features).

The latter is open-sourced under MIT: https://github.com/eatmydata-org/eatmydata

I've been learning Basque and wanted to see a visualization of how the semantics move into different grammatical structures when translating between Basque and English/Spanish.

Under the hood it's using Stanford NLP to analyze the input then that analysis is given to Claude to generate the data structure needed to visualize the translation. It's really cool and maybe my favorite of the itch-scratchers I've built for myself over the years.

(Xingolak is Basque for "ribbons," a nod to the visualizing metaphor used in the UI.)

I spend all day working on AI related stuff at my day job, but more recently I have been getting lots of questions about AI from friends and family and that ramped up when the Vancouver school board announced they were rolling out Copilot across high schools.

I put together the guide, made a few iterations and published it and now I am getting more questions than ever and it's turned into a blog too.

I'm having fun but it definitely feels like a topic that is underserved. A solid example, lots of resources for when your kid is the victim of a deepfake, but what if you as a parent know your kid is getting into trouble and escalating. Where do you go for help to make sure they don't escalate from unfriendly behavior to abusive or even criminal.

It's a big challenge!

It was an interesting project since there were so many unknowns, like can we really turn an offline desktop app into a collaborative one, can it be fast enough, can we port the graphics parts. It turns out you can! I have a semi-vibe coded landing page now, you can sign up to get into the alpha cohort: https://www.pcbjam.com/

This time - I'm so close! I probably need few more weeks to somewhat polish the game and fix the rendering quirks and I'll be ready to put it online for easy access when I'm bored lol.

So I've been working on https://fringeflypost.com/, an event tracker with maps, search and filter, scheduling, and sharing with friends that's offline first. It syncs down a locally stored sqlite database and caches assets pretty aggressively.

(You don't actually need to sign up, and you can just jump into the list of shows directly here https://fringeflypost.com/shows).

The idea is a project independent knowledge base so agents stop figuring out the same API quirks again and again and instead write down what was solved once. Agents submit via API, vote on each other's entries, anyone can read on the site.

Some thousand entries so far, mostly seeded by my own agents, dev infra stuff and so on. Some of it is real problems i hit in my own projects.

https://hivebook.wiki

It provides digital loyalty cards for cafés (think of an electronic version of paper stamp cards). However with zero apps or customer signup, instead loyalty passes go straight into Apple and Google wallets.

It’s written in Ruby on Rails, which I’m enjoying learning. Still a bit rough around the edges, though it’s free for now so I’d be grateful for your feedback.

Thanks!

Website: https://PuzzleLair.com

[0] https://github.com/asamarts/alint

Usually, I barely report on this thread once every few months, but this month was highly productive:

1. I changed how lists appeared in the UI to fix a very annoying pattern where users were confusing lists and things. 2. I finished adding image uploads. Now you can add and view image attachments.

This was quite a challenging task because there are a lot of security implications, and Cloudflare Workers don't support sharp. So I was implementing all the pixel bomb detection, optimizations, and other stuff by myself. Also, self hosted https://imgproxy.net came in handy as a price-efficient image processing solution.

While images are seen in List view (with a layout I'm very proud about!), gallery view is still under testing, as I'm still not completely happy with how it integrates with previous UI decisions. 3. I developed, and delivered ton of small QoL features and bugfixes. Also a few bigger features are in testing. 4. Generally, the app is close to being feature-complete for V1, so I'm slowly starting to work on marketing. It is way less entertaining than reiterating on the same for 2 years straight:(

https://open-write-studio.com/index.html

Although the goal is to build an efficient all-in-one-workspace, I wouldn't run a company on it just yet. Right now I'm looking for early adopters who don't mind the rough edges and relatively minimal feature set.

You can grab an early build at https://alpha.totemkb.com.

New workspaces will be in a 14-day 'trial' mode, email rohit@totemkb.com if you'd like me to upgrade your workspace free of charge.

Like many software rasterizer projects I used Fabian Giesen's software rasterizer blog series [0] as the baseline.

For solid color triangles with depth testing my 10+ year old laptop achieve ~3.2 Gpixels/s fill rate, which is above 80% of the available memory bandwidth (~26 GiB/s at 64 bits per pixel), using memset as the baseline comparison.

I used Rust and std::simd. The code can be compiled for SSE2, NEON, AVX2 or AVX512 by changing compiler parameters. The inner loop uses 16-wide vectors (512 bits) although my computer only has 8-wide AVX2, but the compiler deals with that. I used generics so I can change vector width easily and have multiple vector widths in the same binary for benchmarking. 16-wide is about 10-20% faster than 8-wide. I was excited to see that AVX masked store instructions get used even though I did not explicitly write masked stores in the code. I spent a lot of time reading the disassembly of the generated code and it's very tight.

The performance falls off a cliff (170 Mpixels/s) once I introduce a "shader" in the inner loop because it is not SIMD friendly (one pixel at a time, not 16 pixels). But that is fine, I am intending to use this with visibility buffer style rendering (store integer triangle id's in color buffer) and/or software occlusion culling (depth buffer only). Neither technique need anything more than solid colors and z-buffer.

[0] https://fgiesen.wordpress.com/2013/02/17/optimizing-sw-occlu...

As it's open source and built with a codebase that's easy for LLM's to work with, users can download it and tailor it to their business/operational requirements, although it also has out of the box 'industry best practice processes' so you don't have to reinvent the wheel and can only focus on writing the 10% custom stuff which differentiates your business.

As all the processes are flexible, you can also do proper 'continuous improvement' with your staff - something traditional WMS products struggle with.

No link because I'm finalising it at the moment, but if you are interested please reply!

Still working on my programming language which makes your game multiplayer automatically. Currently working on improving the tutorials. When writing the tutorials I followed the "focus on the action" principle from Diataxis (https://diataxis.fr/tutorials/) perhaps too much. Easel is a unique language in a number of ways and it really does actually have to be taught, so I'm trying to make it do a better job of that.

I also am working on https://trypixie.com - a way to employee your kids legally. It gets money into their Roth and saves you taxable income all while teaching them about working.

The project aims to scrape location data and other general information about shops (main use case), postal addresses, restaurants, schools, weather stations, marine buoys, traffic cameras, street trees, whatever someone may decide is worthwhile to add to OpenStreetMap, or use as location data in other projects.

There's a decent community of contributors keeping the scrapers maintained and further expanding the number of points of interest which are extracted.

The opportunity I'd like to work more on (time permitting) is the data scraped by this project I feel is heavily underutilised in other open source/community projects. For example, there's a great opportunity to generate a location map once a week of current locations of international restaurant chains, and upload to Wikimedia Commons where every language Wikipedia would gain a high quality infographic of current locations of a chain's restaurants, etc. As an additional example, time-series data from ATP could be used to update a graph hosted on Wikimedia Commons each week where the graph plots the rise and fall of retail or restaurant chains.

Each week, everyone emails in a few photos and a sentence or two, and Dearest sends the group a private Sunday digest with everyone’s updates. The catch is, you only receive the digest if you contribute that week.

It is meant for families, old friends, grandparents, siblings, or any small group that wants to stay close without another app or endless notifications.

It’s my way to be social and know what’s going on in my friends lives without social media.

So far I only have my friends using it but I love it.

The concept was, what if Theme Hospital was about Victorian-esq research institution instead of a hospital? You hire strange scientists, have them explore dangerous fields of research, collect messy findings, turn them into theories, prototypes and eventually products, all the while trying to convince investors they're worth funding before they hit the market and work out what they might actually be worth

The gameloop is broken down into two parts, Exploration / Discovery and Exhibition, the closest comparison I have for the first part is take Kerbal Space Program, but focus it on Mission Control rather than the astronauts

While the mad scientists are going into weird, unstable research domains, the player is managing the institution around them, funding, equipment, research direction, safety

On the other side as you discover interesting things or successfully develop prototypes worth showing off, have investors show up and see what excites them, will they give you more funding? Push a grant your way? How are you going to keep this circus going?

You're balancing two plates, you need to invent tools to delve deeper and if you don't keep finding exciting new discoveries, your investors will slowly get bored of you

- https://www.ironvolume.com/ for generating crossfit, hyrox and athx workouts and warm ups, with a few posts on topics I've found really helpful to train around.

- https://pokerchallenges.com/ for practicing the maths behind different aspects of playing texas hold'em poker, trialling it at the moment so can give anyone a free membership if they want to get to grips with it

- https://typst.app/universe/package/calendaring/ a typst calendar grid generation package

- https://github.com/TAJD/cofferdam a tool to help with implementing code architecture compile time checks, helps give agents relevant context on how well their code fits in with the wider codebase without them having to read it all

https://soberstack.app/

https://github.com/tweibley/rubyrlm - MVP Ruby implementation of Recursive Language Models (RLMs) that uses Gemini as the model backend and a Ruby REPL for iterative reasoning.

https://github.com/tweibley/legate - Framework for building AI agents in Ruby with dynamic tool selection, multi-step planning, and session management

https://insightclips.com - Create personalized event videos (with optional CTA) — from first promo to final recap automatically.

https://freshdeck.app - Presentations that design themselves.

https://yourslidessuck.com - Get your pdf/slide deck roasted for free.

https://seriouslygreatjob.com - Put someone on the "news" for free.

https://www.sayayeaye.app - IOS/Mac OS client for Google's Jules.

https://npsbeacon.com NPS survey and analysis tool. I built this because I needed an easy and cost effective way to manage NPS surveys and almost had a heart attack when I learned what some of the competitors are charging.

https://contributoriq.com/ Helps tremendously with the M&A process during due diligence when you need to quickly understand who are the SMEs in specific parts of code base.

https://dependencydesk.com Another M&A tool. Useful for software company sellers who are required to disclose details related to software IP ownership such as what third-party dependencies are used in their software.

https://securitybot.dev All-in-one security, uptime, and SEO monitoring tool. I love working on this, and it has been so useful helping to identify various issues in my other products. Simple Slack alerting integration.

https://iterops.com Heatmap, rage click, dead click, simple A/B testing tool. Like NPSBeacon I built IterOps because the competing solutions are charging far too much for what they offer.

https://spiesindc.com One of these projects is not like the other lol. This is that project. Cold War history / stamp collecting subscription service. I probably lose money on this and yet will never stop running it.

My personal rule is to only build side projects that I plan on using all the time. Otherwise I'll just lose interest and they will languish. So far, so good.

I've primarily been testing it by building out my AI tool chaz into an Eidetica-native AI Agent framework for decentralized Agent sessions. It's working surprisingly well, it maps pretty well onto the storage model and it's uncovering issues with Eidetica I need to fix (which was always my primary reason for building it anyways). https://github.com/arcuru/chaz

Separately I'm building OptiMap, a SIMD-accelerated hashmap repo that explores the design space for hashmaps and benchmarks different approaches. This is mostly for my own learning but I'll eventually turn into a blog post. https://github.com/arcuru/optimap

We're very close to 10M weekly downloads https://www.npmjs.com/package/@electric-sql/pglite

Lots of ideas in the pipeline on where to take it next.

I'm also looking into coding harness self-improvement [2]. An inner LLM (raw LLM request) + harness solves coding tasks, an outer agent like Claude or Codex that proposes harness changes. I experimented with many things in the past few months that made me realize this self-improvement thing that everyone is talking about is just an experiment design problem. I wrote about it here [3]. I'm continuing to improve the infra around the self-improvement loop, to increase signal-to-noise ratio per experiment. I'm also generalizing the infra to expand beyond terminal bench tasks and to collect some data across different models (harness-bound vs model-bound).

[1] https://github.com/workofart/ml-by-hand

[2] https://github.com/workofart/harness-experiment

[3] https://www.henrypan.com/blog/2026-05-25-self-improvement-ha...

I'm a long-time user of Monica (https://github.com/monicahq/monica/) but was unhappy that not much was happening. There is Chandler which is the next-gen version of Monica, but it has taken a direction which I don't like, as it is geared more to journaling. The thing that moved me to implement something myself was that the carddav interface duplicated the contacts in my address book.

I required a tool where I can put my contacts with all their details and also map out their relationships and put those details in my phones address book.

I'm dog fooding it already for as long as it was working, and I'm delighted with it.

I'm happy to hear feedback.

https://github.com/datenknoten/freundebuch/

Its still in the building phase but what I have currently is at:

https://locallane.ai

Essentially, its a platform that takes in any study or learning material (epub, images, audio, lecture notes, etc) and it uses a series of AI models to create multimodal and interactive learning experiences adapted for 7 types of neurodivergent learners (adhd, dyslexia, asd, dysgraphia, etc..)

Based on this work, there's now a new suite of tools for producing games under the Faxanadu engine, new major mods built with all this, and some work on a modified ROM better built for porting and modding.

Disassembly is here: https://chipx86.com/faxanadu/

And I've been blogging about it at https://chipx86.blog/

Building a universal web-based retro game modding tool along with that work called Nostalgia Studio. The idea is that there's a core foundation for representing game state and building editors, a platform-specific layer for representing things like the NES APU and PPU state, and then game-specific implementations that populate state for two layers below.

Those are the hobbies.

Day job, I work on Review Board (https://www.reviewboard.org), one of the original code review products. We just released Review Board 8, which was a pretty large project (we built Office document review, browser-native spell checking in CodeMirror, a new interdiff filtering algorithm, Forgejo integration, and a bunch of other things).

So now I'm working on plans for Review Board 9, with a goal of releasing within the next 4-6 months. Got some thoughts on how the review process can be rethought for this current era of development, so starting work on that.

Out of my love for weightlifting and iOS native apps I began building Plates as a one-time purchase for the full, premium experience. Completely native with SwiftUI and some UIKit. It has been half a year since I first released it and still going strong. Adding more and more features I myself find worthwhile as time goes on.

App Store: https://apps.apple.com/dk/app/plates-weightlifting-log/id675...

Website: https://useplates.com

A complete desktop app for browsing and editing your Postgres, MySQL, SQLite data, creating beautiful dashboards, and soon designing automated workflows for repeat tasks.

[1] https://dbpro.app

I've kept a devlog of the last 10 months of building DB Pro, which has been the best way to bring users to the product. I'd highly recommend folks starting a devlog if they can.

I think the main reason is that the West has quite limited access to pro-level teachers (similar to how chess is like in Asia, just the other way round). Most pro-level Go teachers in Asia do not speak/read any foreign languages (e.g. English), so I want to remove the language barrier and make high level of Go teaching more accessible to the Western world (so that the Go population there will increase). Several European users used it and the feedback was good (and recurring purchases). The translation part is working quite well (Go-specific domain translation), and I hope it will help more foreign Go enthusiasts improve their game.

https://badukteacher.com/

Out of curiosity, I tried using AI for help by scanning the paper and the feedback for improvement was quite good (definitely better than mine). So I created an Android app for this (no iphone for now): you write on paper, take a picture and get feedback on what to improve

https://play.google.com/store/apps/details?id=com.handwriteh... (has 5 free tries per month because the LLM incurs API costs)

Recently I've been trying to expand it from just coding focused to any kind of agent workflow. So now there are cron and webhook triggers, and more general agent tasks that aren't necessarily coding focused (https://github.com/jonwiggins/optio/blob/main/docs/persisten...).

I think next I want to try and add features for long term memory for agents, but haven't decided on a good way to do it.

I’m still actively working on it but just submitted to App Store review. TestFlight is open if anyone wants to try it before launch: https://testflight.apple.com/join/baWAQ4tj

Happy to hear any feedback, especially from people who currently store recipes across Notes, screenshots, and 15 open browser tabs.

I am actively working to support iOS 27 (and the other 27 OS’s) and will be posting development updates over on mastodon: https://mastodon.social/@saxtechsolutions

Hister is a full text indexer for websites and local files which automatically saves all the visited pages rendered by your browser. It provides offline result previews, a flexible web (and terminal) search interface & query language to explore saved content with ease or quickly fall back to traditional search engines.

I've been using it for a few months and as my local index is growing I can avoid opening google/duckduckgo/kagi - and even websites listed in results - more and more frequently.

The initial reception is overwhelmingly positive with already more than 30 contributors and hundreds of contributions - perhaps you can find it useful as well. (Or at least have some constructive criticism =])

GitHub: https://github.com/asciimoo/hister

Website: https://hister.org/

Small read-only demo: https://demo.hister.org/

tsz is my main side project. Trying to learn from this for how to make software in fully automated fashion. tsz's goal is to match tsc (tsgo) but perform better. I am not passing all tsc's own test cases and working towards making it work on complex type packages.

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

2. Continuing work on Standly, a standing desk app for iOS and Mac (https://apps.apple.com/us/app/standly-standing-desk-timer/id...). I just grossed $1000 total on the app and get few customer feedbacks a week which is very exciting.

3. Almost finalized the first episode of my labor economics youtube channel, hand animated by a team of amazing artists. Looking to build it into a sustaining channel.

4. Building a server-driven UI framework at work with Go and OpenAPI on server side, swift and kotlin on client side.

I've also recently setup Hermes to be a bit of a project manager for my side projects and it's worked quite well. Gave it a little CLI to see my todos, projects, and "areas" (ongoing long term things). Then it bugs me once in a while when a project is going stale. One of the nicest things is being able to add stuff to the past so if I did work on something but it wasn't associated with a todo I just let it know and then it'll backdate that.

I went on sabbatical to fulfill my dream project - consolidating 30 years of training logs that span everything from paper and Excel spreadsheets to various fitness services and devices I used. I'm enjoying the technical challenges involved - digitizing paper hand written logs using OCR / visual generative models, navigating the maze of athletic metrics with their crazy trademarked names and SOTA multidimensional models. Having incredible fun building AI coaches: agents ranging in character from Al Pacino in Any Given Sunday to the coach from my teenage years, utilizing ICL / PFN model-based predictions, ... and more.

The best part is the rush of memories while ingesting my own history - photos and recordings I completely forgot, as well as navigating data shared by friends - records they didn't see in years because the original applications they used no longer exist or won't run on their current HW.

I'm also building a modern HTTPS-only transport utility called curb. It's an alternative to curl and wget. It's written in Go using only the standard library. curb can stream output or download files and picks the right behavior based on what the server returns and whether the output is going to a human or a pipe. It also has a '--vet' mode that runs the body through security sieves; this is meant to add some protection and friction for the 'curl | sh' use-case. https://gocurb.dev

I built https://loracle.app to automatically build a wiki of various entities in our campaign and enable rag q&a with an ai assistant about specific world facts.

Overall it’s been a fun learning experience and I’m looking forward to some more of the hardware work I’ll need to jump into soon. I really want to get a more focused kitchen / cooking oriented voice assistant working. So far I have a few simple voice-to-timer settings done e.g. “set a 10 minute timer for the pasta” that tells me “ding! Pasta timer” when it goes off. You can set as many concurrent timers as you need with different names.

I need some better hardware before I try using the pi for full hands free while cooking. I’ve mostly been using a webapp on my phone but afaik you can’t easily wake word a phone on a web app without some real hacking.

Overall the projects been enjoyable, once you understand the basics of a harness it feels like there’s a lot of problems you can throw them at.

If you are a privacy minded person like me, you got only a few options when it comes to email with some ease of use: ProtonMail, Tuta etc. Rather than becoming a new competitor to those, I want to give the power of the decentralized email standard back into the users hand. Everyone with a bit of self-hosting/Linux knowledge, can setup their instances for themselves and their friends/family/business.

Bootstrapped that heavy via vibe coding. Used it to learn a lot about the email standard and related technology. However, I find it too valuable to just be a learning project. Now I'm cleaning it up to get in control again and to proof its secureness by rewriting/restructuring/refactoring line by line.

My first goal is to 3d-print frames for reading glasses that I can wear in bed while I read. This way, if I fall asleep with them on and break them, I can just print new frames and pop the lenses in.

My mother had a stroke a little over a month ago and I don’t live close by. I went in search of a wellness product that would let me know how she’s doing without her feeling I’m prying too much. I didn’t find one, so now I’m trying to build it. I’m also working on moving closer.

Yes, the burden should not lie on the author, and you could argue it's not even relevant. Still, the default has shifted and there's a refreshing feeling when you're forced to choose your own words.

This is not perfect. You can still find ways to have a machine write a text into this box. But what's guaranteed is the time: writing a message takes the time a human would actually need.

At the very least writtenhuman.com is a statement that the problem it's tackling is real. One with the potential to become a global crisis.

(plausibility 100/100 · mean 58 wpm · peak 108 wpm · cadence 4.5 keys/s · duration 2:56)

Verified human · www.writtenhuman.com/v/m7h8asjd

Side effect: KYC gets stupid cheap. Cryptographic credential verification vs. traditional document checks is not even close on cost (≈90% cheaper). Qualified Electronic Signatures and EUDI Wallet Payment systems are also coming in the following years.

https://www.authbound.io/

https://keibidrop.com

https://github.com/KeibiSoft/KeibiDrop/

It leverages virtual mount points to make file metadata available between Alice and Bob, and make the files appear as if locally.

So for example instead of waiting to upload then download a Blu Ray movie, or a large game, you can just add it into the virtual mountpoint and your recipient can instantly play it, or install it, and the download happens in the background with random offset jumps, and caches it locally.

And so I built it: https://reproof.app/

It's taken forever (never reinvent the text editor, they say, and they're right) but it's finally at the point where a handful of us are using it for daily writing, and it's just about ready to launch.

I didn't want to run a Windows host for any of the existing solutions so have targeted the Raspberry Pi Zero 2 however the app does compile to Linux, MacOS and Windows so it can run on anything. For the wind simulation I'm playing with an ESP32 based PWM controller which connects over Bluetooth using a custom GATT profile.

I've mentioned it here and there online but have yet to see anyone actually use it other than myself.

https://www.simtezilo.com

I'm trying to build more things around AI pixel art - honestly, I think it's crazy some people out there are charging money for things like this and seeing where I can help (and also just learn more about this stuff myself).

[0] https://oscarsanchez.com/tools/pixelaid/

So I built an app that combines that workflow with some code dependency graph and sandboxing ideas (semi-structured build manifests with auto-installing tools / isolation) from a startup I previously co-founded, along with a handful of other tools / features (like virtualized code workspace over gRPC that works locally or remotely, starlark for scripting, a debugger with an investigation log and proposed fixes, dependency analyzer, security reviewer, and per-agent models/providers so I can use more expensive models for more complex work, like design or debugging work, and cheaper models for writing code) and built my own day-to-day development assistant that I’m pretty happy with!

As an added bonus, since I don’t like being stuck with one provider, it supports most any LLM provider (including local ones) and I can seamlessly switch between providers or models in the middle of my work if one is offline or going in circles.

In the UK alone, around 7.2 million people have asthma. Globally, WHO estimates that asthma affected 363 million people in 2023 and caused 442,000 deaths.

Peak Flow Meter Diary is not meant to detect every possible trigger. It will not warn you if someone suddenly sprays perfume nearby, or if a dusty bag is opened in the same room. But it could help with risks that can realistically be monitored ahead of time, such as weather, pollen, pollution, cold air, storms, and similar factors. The aim is to make daily tracking easier, show simple visual warnings and notifications, and make it easier to share useful records with clinicians.

I’m also trying to build it in a way that reduces paper, plastic, and electronic waste. If funding allows, I would like to make the project carbon-negative.

That is the bigger dream: to make a small example of how even modest start-up can think about environmental impact from the start, and use it as a practical showcase.

The pitch and full project explanation are here: https://www.kickstarter.com/projects/why5/peak-flow-meter-di...

Feedback welcome, especially from anyone with asthma, clinicians, carers, or people who have worked on health tracking tools. By now I know that my kickstarter is not going anywhere, so I would value any input was the idea that bad, or lack of marketing and accessing appropriate groups etc. I think this community has a lot of experience so I would like someone to share what could have I done better. Do not be shy to tell me if you think idea was waste of time.

Most agents for durable workflows feel like toy examples. There is no "Codex" or "Claude Code" for, say, Temporal. So I'm building full-featured agent for these runtimes. Why? Because it makes long-running agents easier to operate and scale. Currently, all frontier harnesses need to run inside a guest OS and need a dedicated process, this is quite challenging to orchestrate and maintain.

To make it work, I had to figure out what part to run as deterministic workflow code, and what part to run as I/O or side effects (aka activities). I'm using a CAS for most of the payloads to maintain a lightweight footprint in the workflow code.

Currently supporting skills, MCP, prompts, a virtual file systems, and soon sandboxes.

https://github.com/smartcomputer-ai/lightspeed

I have already finished training the standard discriminative auto-regressive architectures by imitation learning on player actions, compared it with previous baselines set in the study. I want to match or exceed the best prior model Kakuna @ 142M params, but in a limited budget. JEPA style world models are showing promise when conditioned on actions [1] and frontier research on JEPA with trajectory straightening [2] shows that improved planning is natural outcome of improved representations.

If any good research ideas come out of this exploration then even better!

Currently fork with my models: https://github.com/sooham/metamon (under checkpoints) Orginal source for pokeagents: https://github.com/metamon/metamon

[1] https://arxiv.org/abs/2603.19312 [2] https://arxiv.org/html/2603.12231v1

A good primer on world models from Welch Labs - one of my favourite ML youtubers: https://www.youtube.com/watch?v=kYkIdXwW2AE

Another project is https://www.beeldplek.nl, a timelapse platform powered by community photos. The idea is to place a mount and QR code at fixed viewpoints around the neighbourhood. People scan, photograph the view, optionally add their name, and submit. The infrastructure is up and running but getting the permit to place the mount has been a slow process so far.

Instead it's just a compass face, with brand and distance.

It's free for basic konbini hunting (has probably most of the stored in Japan), and is offline first. So maybe it's useful to other folk?? (I hope so!)

There's some stamp-book style collection things in there too, but that's more fun, and a few `PRO` gated things (more stats, filtering... soon some other store types). But none of it required for finding the next Biru or coffee.

*https://apps.apple.com/us/app/achira-japan-offline-guide/id6...

Working on it has been a joy as ad-blocking tech touches so many aspects of software engineering - from systems and security to the intricacies of JS environments in browsers.

Benefits-wise, system-wide filtering disables ads and tracking not just in browsers, but desktop apps as well (which you'll be amazed how much they do). It's especially relevant now as Google is re-activating their efforts to hinder ad-blockers by killing Manifest V2 in Chrome. So much of tech is actively bleeding cash on AI right now, which means the efforts to screw over users will only accelerate. This makes something that sits at the network level indispensable imo.

Anyways, here it is: https://lorepanic.com/landing-new

https://waboost.com/

We are in the process of writing our own vertical stack with Go to control the machine instead of expensive and handicapped solutions from Siemens and etc.

Merged minimal OIDC support in Vaultwarden last year (https://github.com/dani-garcia/vaultwarden/pull/3899)

But still maintaining the fork with additional features :).

https://github.com/linsomniac/apt-cacher-ultra

The primary features I'm focusing on are: It can serve packages if the upstream is unavailable or corrupt, it is reliable.

It snapshots and verifies the cache, and then only updates the snapshot when: a new metadata is available, it has downloaded updated packages that you commonly request, all the metadata checks out.

It's been running in my environment with ~200 clients, ~50 of them get reinstalled every day and then do a full set of package updates and installs. Been working great, even when I shut down Internet access while doing it.

(V)RAM conscious AI inferencer/generator: https://github.com/cretz/thinfer

https://williamcotton.github.io/datafarm-studio/

One of the DSLs is:

https://williamcotton.github.io/pdl/

The other is:

https://williamcotton.github.io/algraf/

Full LSP that is built into the binaries and compile to CLI and WASM. Full LSP support in the Monaco text editor npm packages that use the same static analysis crate as the VS Code LSP client.

Native GIS with GeoJSON and Shapefile support for both languages.

Lots of fun and novel problems to solve across hardware, software, firmware, enclosure, legality, manufacturability! It also got me collecting random carts just to hear the incredible music locked away (some samples at the end of this video https://www.youtube.com/shorts/7naKAga8hAE )

https://croncoco.io

Crossed over 100K MRR and I'm shooting for 2M ARR by the end of the year. Growing something in this stage is totally different from making it go from zero to one so it's an interesting learning curve. AI has also changed the calculus as well where it seems less crazy to try and do this sort of thing. Time will tell!

https://logging24.com/landing_a/

The basic idea is to make Regex-scans so fast/cheap that "a metric" can be anything numeric in the text and "tracing" is useless because you can just log (and filter) more things. Turns out Regex at >200GB/s solves a lot of problems.

Metric cardinality explosion is immediately a non-issue, histograms have arbitrary resolution, and you can get from histogram pixels back to the underlying logs. And no need to instrument everything thrice for logs, metrics and traces.

The next big feature I'm aiming for is needle-in-a-haystack searches. The data block headers support it already, but the scan engine doesn't yet use it.

By default, home page gives all models in the leaderboard, local and hosted. Search for models in the search box on the home page to find the top models by ranking, local(by size) and hosted (by price).

You can also do deep querying/sorting/searching filters of models in each of these three nodes (see the other tabs on top).

The next steps I am working on (would love feedback on this or anything else):

Phase 1: - Change clicks on home page model tiles in one column to search and show models filtered by that across Artificial Analysis, Ollama, OpenRouter - User specifies their system VRAM (unified/dedicated) and we automatically filter the home page with models that would fit on that RAM - in the three columns. - User specifies their price range (per MTok, max across input and output), and we similarly filter and rank by those models across all columns. - User specifies both (VRAM and price range), and we filter by both - leaderboard is union of local and hosted, local by VRAM and hosted by price range match.

Phase 2: Once I have this working, add a local desktop client that automatically reads user system and infers VRAM, renders app as webview. Considering pyside6 with Qt for this.

Phase 3: On desktop client, user can download and chat with the local models automatically based on leaderboard, optionally call hosted models, etc. Used primarily to evaluate and compare local vs hosted models for user's use cases. Also have some interesting alternate experiences to host within the local private app for user to interact with llms, agents, etc.

Do let me know whether this seems useful, or how I can make it more useful.

https://head.ball.coach/

I started working on this in my free time in 2010 or 2011, and initially used it as a project to learn databases, cloud, et cetera. I never actually set out to be a game developer!

So this is my first attempt at game design, and has its share of issues, but I'm proud of it.

i've spent the last couple years experimenting with LLMs that write procedural, ambient music: instead of generating an audio file, we're using systems that write actual source code (supercollider synths) so the music runs live and can be embedded in and controlled in real time by software like games. a surprising amount of the work is taste -- prompt engineering and curating an aesthetic so the generated code reliably compiles and sounds good, with a compiler and automatic repair in the agent loop when it doesn't build. today, it produces single-synth musical systems, but I'm researching how to orchestrate multiple synths into fuller, evolving compositions with deep musical form and structure. LLMs make algorithmic music far more accessible to artists, and I'm eager to hear the new kinds of music that come out of it. hit me up if you're an audiophile interested in collaborating.

listen (or remix!) a couple examples:

https://underscore.audio/s/cmp_3d4ee881-1ec/elegy_lattice

https://underscore.audio/s/cmp_a2baeae6-3f2/supreme_ember

-----

2. Makespell - https://makespell.com/

a little suite of word games I've been building as the testbed for Underscore. every puzzle is generative: crosswords with LLM-written clues, a word ladder, a guess-as-it-draws game, and a deduction game scored on how few clues you need. the crossword grids come out of a Rust constraint-satisfaction solver — backtracking fill over a bitmask-indexed word list, enforcing 180-degree rotational symmetry and slot intersections. each generated puzzle gets its own generated, continuously-evolving soundtrack with no audio files involved. right now, the music is generated per puzzle, but it needs some work. it's currently too drone-y, and needs to be more magical/whimsical. where I want to take it is having it respond to the gameplay itself — which is really the whole point of Underscore

I made it because doing one of the mainstream Markdown renderers + Katex (LaTeX) + Prism.js (syntax highlight) adds 300kb of gzipped JS to the frontend projects, so with this you can have it all for just 10kb. It also works well with streaming/does stable partial rendering.

It supports features usually reserved for LLM chatbots, but also for normal everyday Markdown, so feel free to use it or give feedback!

Most interesting work this month came from a customer in Japan who wanted something I hadn't built called "Easy Japanese" (やさしい日本語), which is like a simplified version for non-native readers. Turned into supporting fully custom locales. Also been improving how the GH action picks up manual changes to target translations in commits, they now get ingested back for review, making things a bit more flexible.

On the side, https://infrabase.ai (AI infrastructure tools directory) had its best month yet, up ~40% visitors MoM. Interesting finding is still the GEO angle, visitors arriving from Claude/ChatGPT/Perplexity spend 2-6 minutes on the site. Been making comparison pages more "extractable" for AI answers with job-tagged tables and some have now held their Perplexity citations for weeks.

Good start of the month with user discussions and feedback.

> gmd indexes local markdown with full-text, vector, and hybrid search on Typesense; web search, fetch, crawl, and research; llm-wiki pattern and agents; local or cloud.

The app tries to help build good habits - Encouraging and motivating users to achieve their goals.

https://apps.apple.com/au/app/training-cadence-workout-plan/...

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

https://brynet.ca/wallofpizza.html

Also been working on a mod for a SNES game I grew up with as a side project for the last 12 years or so, and I promise that one day I actually hope to finish it. It's just I have a really bad tendency to fall victim to scope creep/feature creep, and that only got worse when I taught myself 65c816 assembly language and decided I'd add 3-4 unique mechanics per level in the style of games like Donkey Kong Country Tropical Freeze.

Everyone is working on personal agents but their identity model is wrong. They act as you, risk your reputation, your data and more. Nym is a personal agent that has (and can make) all of its own accounts and only gets selective read only access to yours.

The goal is to make reliable agents that are able to operate safely in the world to help you do what you want, without exposing your accounts and personal identity to potential harms.

For instance nyms have their own e-mail addresses at nym-mail.com, you can CC them on chains and they can only respond to people on that chain with a lease of 5 days, or permanently for people you specifically add.

Rust-based hybrid search engine: https://github.com/DeepBlueDynamics/lume and https://github.com/DeepBlueDynamics/shivvr

Agentic terminals: https://github.com/DeepBlueDynamics/hyperia

More broadly, I spent ages developing a self-solving Kanban for mid-sized companies and enterprises (https://kodan.dev) - controllable autonomy level, multiplayer support, remote coding server, works on multirepo projects, mobile support, previews, and more. The pain exists, but it's pretty hard to break the integration barrier.

So I'm spinning the feature I used the most into a separate, easy-to-understand product for now.

The client focuses on extensibility, IRCv3 compatibility, and a modern UI and UX. I am realizing that IRCv3 is capable of being built on top of though, so I may start incorporating external features outside of the protocol itself.

Some friends and I have also been building a start up a month and the latest one to come out of it is medspa software: https://spaarc.net

tird /tɪrd/ (an acronym for "this is random data") is a steganographic storage and file encryption tool.

With tird [0], you can:

1. Encrypt file contents and comments with keyfiles and passphrases. The encrypted data format (cryptoblob) is a padded uniform random blob (PURB): it looks like random data and has a randomized size. This reduces metadata leakage from file format and length and allows cryptoblobs to be hidden among random data.

2. Create steganographic (hidden, undetectable) storage (tirdFS) inside container files and block devices. Unlike VeraCrypt and Shufflecake, tirdFS containers do not contain headers; the user specifies the data locations inside the container and is responsible for keeping those locations separate. Any random-looking region of a file or block device may be used as a container.

3. Prevent fast access to decrypted data using time-lock encryption.

4. Use additional tools:

  - Create files filled with random data to use as containers or keyfiles. 
  - Overwrite the contents of block devices and regular files with random data to prepare containers or destroy residual data.

See also:

The Problem: Metadata Leakage https://gist.github.com/hakavlad/90153badb552ac28e7573a4df38...

This is basically a rewrite of Netflix Conductor which was the original platform we built while working at Netflix. At Netflix, infra was "free" so we were generous in all the dependencies we had on that - so we decided to rewrite for cost optimization in this version.

Unmeshed eliminates the glue code thats typically written for resiliency or connecting things together. And our design of execution also offers it the flexibility of being used as a real-time API orchestrator. It even comes with a managed SQLite service (as many as you need), which means we don't need a provider like Supabase to work with stateful workflows.

Fun fact is that in our company, everything we use is actually just static HTML UI built on top of the Unmeshed Platform as backend - like our CRM, SaaS management, Deployments, Finance etc.

Check it out here: https://unmeshed.io

Before that, I vibe coded peek – a CLI network monitor, just because I couldn't find a solution that did what I needed it to do (think Uptime Kuma, but less and in CLI). You can try it out from here: https://github.com/hxii/peek

Now:

1. I'm trying to learn some Swift and SwiftUI so that I can give life to a ADHD-inspired idea I had a year ago that will help me maintain the "one input" framework I created for myself in 2023 (https://0xff.nu/productivity/#the-possible-solution) 2. I'm trying to find a job in a hopefully normal company

That is why I created Dhee Desktop / Dhee Core ( Open Source https://github.com/dheeai/dhee-desktop https://github.com/dheeai/dhee-core ) - which allows anyone to author and run their own workflows for creating AI videos. Its local first, fully customizable, private runner for your workflows or any kind of community provided workflows(bundles) too (Comes with a few built in bundles to generate a full multi-scene segment just from story! ).

Its not just a workflow runner, but rather comes with an AI agent to manipulate the generations. AI images and video models often make mistakes ( extra limbs, wrong face etc ), You can ask the Agent to make changes to the prompts, trigger a rerun, Completely change the character and only trigger the exact shots in which he/she appears etc. It knows and tracks the dependencies.

My mission is to make it super easy for anyone and everyone to be able to create AI videos that they want to watch. I am envisioning a future where you make your own movies and watch it on your PC / TV rather than wait for someone else to make a movie that you want.

You can check out how it works on https://dhee.studio

It's pretty simple: just search for the vitamin/mineral/supplement you want, and it displays them all ranked by the most amount of that supplement per dollar.

Multivitamins and Omega 3s work a little different, and protein powders are grams of protein per dollar, but that's the gist. Anyway, the affiliate link isn't even set up yet, but maybe some people could find this useful in their personal lives. Open to feedback!

For now I have a clear vision about what the product should be, what it should do. Mainly, it's a product that should resolve blockers and consensus-seeking problems across time zones.

I'm not sure if something like that would be used, but I really want to try..

It is really really fun, but I have no idea what I am doing.

I really dislike async and will hast asyncheonisity behind coroutines (which sadly will be botched because dotnet). i will use them to implement concurrentML sometime in the future. Not unlike go, but the will be called bjoroutines and soaened with the "bjo" keyword.

Other than that, it is pretty standard hindley Milner, but with some limitations to make parallel compilation simpler.

Edit: och: and i will make comprehensions general. (summing (in-vec my-vec)) Or (folding #(+ % a b) :for a (in-list aList) :for b (in-generstor a-generator))

Here's a live example of it figuring out when to post on HN: https://kavla.dev/hn (spoiler, its noon UTC on Sundays)

And here's it generating an interactive map of 20000 earthquakes: https://kavla.dev/quakes

I feel like the canvas is actually a great way to interact with an agent, everything it does is visible, so auditing what it did is (relatively) easy.

I still got some credits to burn so agent usage is free atm (you still have to sign up to use it though)

I am close to buying a Claude sub but the thought of it going haywire and costing me extra money in tokens is too scary yet. Not to mention how much provider LLMs (not sure on the correct terminology for them as opposed to local) could hamper your reverse engineering efforts (looking at you Fable).

I really want to solve this scooter and have my own app for it. There's a firmware update feature in the app, maybe I could dump the firmware at least and that would help. Anyone have suggestions on what language model would be the best for this task (analyze decompiled and obfuscated android app / analyze dumped firmware ) ? i have a 96gb macbook and would prefer a local one (I guess to make myself feel better for having spent money on it?) but something through OpenRouter or whatever would do just fine as well

You use it to 'rank' any abstract entity you choose. The idea is that you'll be able to find common things you like across categories (I think the type of books you like probably influences the kind of movies you like!)

https://rankr.click/

Learning FreeCAD to create a sliding insert between the body of the phone and the screen. If I can pull that off the rest should be easy.

Unfortunately the controller board will have to connect to the phone over BT although it will use the phone's battery. I wanted to connect it over USB internally but there's no bus on this phone and trying to hijack the lines running to the USB C port would be feature creep that would stop the project. Another idea was to take over an I2C line going to some peripheral I don't care about but I think that would require a custom android kernel so BT it is.

By the way this phone is awesome. Highly recommend for anyone who wishes they didn't need to carry a smart phone.

Yesterday, I finally achieved blockchain payload byte-count stability from block 4 and onwards. Today I'm pulling levers to reduce the payload size. Proof-of-everything, so no confirmations needed.

https://bitcointalk.org/index.php?topic=5580132.new

https://kraa.io/about

I know that there are already way too many markdown editors out there, but I think Kraa still offers something unique in this space (combination of minimal UI, plentiful features and some unique stuff like real-real-time chat).

Example of how easy it is to create a 'community' on Kraa: https://kraa.io/kraa/trees

Also - no AI integrations whatsoever.

Texcraft is an attempt to re-implement TeX with a modular/LLVM software architecture. These UIs take the same code in Texcraft that has identical behavior to TeX, and illustrates some of the inner workings of TeX. The lig/kern one is missing instructions :)

I have also found at least one bug in Knuth's TeX recently and am currently writing it up.

The most challenging part was getting MVTs to fly but it is very fast already even in mobile. The fun part is tarring the solver solves correctly :) no public version though but I can upload a screen grab somewhere should anyone be interested.

It's still early days, but I have a demo running. Unfortunately, it requires using a drop-in replacement library for CoreLocation. That alone may make it infeasible.

80%+ done MVP, for small business use & personal use. First go at full stack development with AI. useful features around voicemail, notifications, and spam prevention (whitelist, blocklist). Built to be robust, secure and available.

2. Intelligent understanding for videos, No MVP yet. Have an interface and use-case in mind that allows people to use understand videos with rich context quickly

currently on pause for leetcoding but I think there's potential here.

The coolest feature I added was a tool to handle passwords under duress.

I'm still working on the Chrome version, but this is the Firefox version:

https://addons.mozilla.org/en-GB/firefox/addon/saigon-safe/

Starting with https://anentropic.github.io/duckdb-semantic-views/ which is basically a clone of Snowflake's semantic views but for DuckDB

(see also Databricks Metric Views)

Not sure if I should be monetising this in anyway - maybe through a cloud sync feature. But it's useful enough for me right now.

But the "ai email app" that should've saved time for them, ends up making the user their own assistant.

So I build https://dirac.app , a decision-based, ai-native email app.

This will be the Next Superhuman, and it's launching tomorrow on ProductHunt.

Anyway, I’m working on my manual skills of soldering.

It's been pretty fun to build. Trained a couple of models to identify a card that run on the phone app. They work very well and are comparable, and much better than many, to any other card identifier in the market. As the models get more complicated training is getting a bit longer. I'm at about 9 hours per epoch on my Mac M4 with 16G of memory.

The Android phone app is in public test with a couple of my local group testing. The app is built in React Native, and I’m hoping to get an iPhone version out soon since there are a bunch of iPhone peeps.

In the style of Sauron I’m channeling all my frustration and hatred of slow loading tools that require you to pay a subscription, buy the digital book on every platform you want to use it on, and won’t let you use the physical book from your shelf.

For my first pass I decided on focusing on a character creator for a single game and streamlining the process.

I started with the 5.5e SRD but got frustrated with the sheer amount of text without much actual content ( 100+ A4 double column pages of spells, only 1 subclass per class ). Plus a number of weird and frustrating rules that make it hard to create software for. As I’m using Nimble RPG at the table a bit recently and it has a much nicer license I’ve switched to that and been getting on a lot better. Character creation is almost done and I’be moved to character sheets and persistent object storage now. This is the first major project I’ve done with sveltekit and I’m really enjoying it.

This is the first time I'm building with the help of AI (Claude), but I don't really let it write code. It has been really helpful in discussing ideas (I'm mostly working alone), like a rubber duck that actually talks back. The code it generates however has many subtle and sometimes obvious mistakes in them, so I decided to write the code myself.

The main benefits over the previous version will be:

- Dynamic reports (ClickHouse queries are generated on the fly)

- Better performance

- Much cleaner and less code

- Better and faster data ingestion including new features, like full support for JSON metadata

- And much more

It feels kinda crazy that I've been working on this project for more than 5 years now and it's still exciting :)

[0] https://github.com/pirsch-analytics/pirsch (v7 is the new branch)

[1] https://pirsch.io/

Range of temperature is the big one for rules, but you can also require humidity, wind speed. Eventually would be nice to add air quality if there's a sensor nearby.

You don't need any local devices - sensors, motors, etc. You just get an email/text/web push of your choice when the weather is nice and some fresh air is freely available.

I've had a home assistant routine for this running for myself for years, but the 80% version requires nothing more than weather data. Human in the loop automation (I physically open/close the windows).

My goal with this language was to pick a set of primitives to compose and express as much as possible.

I don't have a demo up yet but if anyone was curious https://codeberg.org/lilbigdoot/gloo/src/branch/thinkythough...

The two main features I am missing right now are recursive types (I want to do proper mutual recursion and have been procrastinating) and some form of type classes or implicit modules. Structural typing has been useful and I'm finding a lot of features are falling out for free from that.

Long term goal is to create something with performance within a reasonable range of C# / Java etc generally, with tools for opting out of GC. I don't plan on chasing zero cost memory safety, since I want to spend my "budget" on tooling and expressiveness.

Until the language semantics stabilize I plan on generating some pretty naive JS/TS to play around with real programs, and eventually target .NET and native (likely via C++ transpilation)

Recently added support for scripts (like Claude code workflows) and been iterating on the UI for that a bunch.

I also ended up wanting other customized tooling - a more streamlined way to grep, find files and review code that my agent has written. So I wrote a few plugins for that : needle (finder with UI and sorting functions that suit me better), shuck (interactive grepper that has a workflow around refining grep commands) and glean (a review tool that lets you mark parts of the code as seen, leave comments, view diffs commit by commit or collapsed, etc). https://github.com/dlants/dotfiles/tree/main/nvim/lua

These are all in various states of experimental and mostly just for me, but a few of my coworkers and friends have been using magenta and like it.

I posted a Show HN [1] here a while back, got tons of great feedback, and have been slowly improving it since, with no real marketing. Another Show HN is probably overdue!

More recently, I've been working on adding features around meeting individuals/smaller impromptu groups over activities you're doing - i.e. "I'm going for a cycle today - who wants to join", so I'm excited to see how that goes. There are some UI examples from that on the landing page.

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

Besides Materia itself I've been bouncing around some other ideas for the Podman quadlet ecosystem. The biggest one is Athanor[1], which re-uses the same plan-execute system and primitives provided by Materia to backup Podman volumes.

I've also been kicking around a clustering system for Podman volumes called Firmament that uses Serf and the built-in Podman import/export API to move volumes to where they need to be in the cluster. But this will probably wait until Materia hits 1.0 before I really start putting effort into it. Or if my homelab needs something like it, whichever comes first :).

[0] https://github.com/stryan/materia ,main site https://primamateria.systems [0] https://github.com/stryan/athanor

In this first round I want to see how players respond to the composure-driven knockdown system, and if they find the sample boss fight difficult enough to be interesting, but genuinely fair. In the background, I'm thinking about how to improve the training mode (it only kind of worked on my daughter), so the game can teach you how to play without telling you how to play.

90s of combat: https://www.youtube.com/watch?v=au6X7snM_G4

I'll also be urging myself to do some marketing during the world cup for my recently released physics soccer arcade game: https://store.steampowered.com/app/3802120/Put_One_In_for_Jo...

Repo with video: https://github.com/monkeydust/rightmind

We’re live in 3 stores and it’s working great.

The system has two parts: a mobile app that lets employees snap photos of products to generate and publish listings, and a hardware box that sits inline between the barcode scanner and POS to track in-store sales and automatically remove the corresponding listing when something sells.

We’re live in 3 stores and it’s working great.

The system has two parts: a mobile app that lets employees snap photos of products to generate and publish listings, and a hardware box that sits inline between the barcode scanner and POS to track in-store sales and automatically remove the corresponding listing when something sells

I figured it would be good to have some minigames in the above so tried making unrelated small turn based games as an experiment.

That in turn led me to making a Soviet tractor factory simulator [1].

0 - https://store.steampowered.com/app/3920/Sid_Meiers_Pirates/

1 - https://alexpotato.com/games/tractor47/?l=hn3

agent-vault-proxy is a local proxy that injects real secrets into requests in-flight, so a compromised or prompt-injected agent has nothing to steal, feedback welcome: https://github.com/inflightsec/agent-vault-proxy

https://www.youtube.com/watch?v=8WMCs4HEO8Q

I started it 2 months ago because I was frustrated searching for AI tools across dozens of different sites. Everything is in one place: compare tools, filter by category, read reviews, find free alternatives.

Covers everything from AI chatbots, image generators, coding tools, video tools, to AI agents.

Updated daily as new tools launch.

Happy to answer any questions about how I built it or what's in there!

It's full featured with agent loop, gets work done locally.

It's open-source and Swift-based, we built our own inferencing engine since every other engine is based on Python. Check us out - https://github.com/osaurus-ai/osaurus

Looking for some feedback!

Native macOS app, and build on top of Wireshark Libs, so you can see packet details like Wireshark, and it's much easier to use.

Open Source and License under GPL-2.0 at https://github.com/ProxymanApp/TCPViewer

Writing a sci-fi book, and it’s finally fleshed out to a point that it’s slightly readable, though more like a script. As this is all in markdown in one folder, with some text files as lists, I started writing a simple web project to keep track of it all.

Created a website for local community information, services, etc. Something that removes the reliance upon social media for this. It’s static, making hosting cheap, and in most cases free as it can run on vercel with contentful for blogs and github to store it. I’m sure there’s another project like it, but it’s always good to practice making something myself.

I was asked to show something for STEM week at my daughter’s school. Started a project to demonstrate AÍ to children. Uses very small training data set, you can write the beginning of a one sentence story, it can keep track of a configurable number of tokens, generates a given number of them. Allows taking steps through the process. This is the only one I’m vibe coding because I’m not entirely sure on how to implement it, plus I’ve added multiple models.

Have been working on a girlguiding page specifically for the division my wife volunteers with, as they relied upon the older district site that’s woefully lacking. Stuck waiting for approval.

It’s founded in Rust and incorporates a Deno runtime for extensions.

It’s headless now, via JSON-RPC. I’ve got the basics of a trait based system which will enable different frontends. At the moment, I’ve created an extension for `pi` which allows me to use that as the frontend.

In contrast to most other libraries in this space, it knows about Laravel conventions and its ecosystem, and tries to infer as much as possible without explicit annotations, using type hints and doc comments and static analysis. Where automatic inference isn't possible, you can use targeted attributes to annotate your route handlers.

The result is written as an OpenAPI specification, and (by default) served using a Scalar playground.

We also include a linter command that checks whether all API routes are documented properly, typed correctly, and following your style - this also supports dirty files only, reporting coverage in standard formats, and even automatically fixing some classes of errors!

I've also written tooling to regularly test the library against a set of open source Laravel applications with a published OpenAPI spec. This has proven very solid in detecting improvements and regressions, so much so that I can delegate new features to an AI agent and rest confident that it can verify on its own whether a change breaks anything.

Human powered proof of humanity. Nothing on chain, no blockchains. Just DNS / SSL like decentralization. V0 is admittedly less decentralized as a POC (I control the registry and provider), but anyone can implement the protocol and make this truly decentralized.

Registry (even the current one) is meant to be government by multiple independent entities.

Shared before, didn't get much feedback. I've used AI extensively but very thoughtfully. This is very much not vibe coded.

The ecosystem includes 3 apps:

https://humanidentity.io: people signup and get verified here

https://app.humanidentity.io: platforms signup here and manage their oauth

https://protocol.humanidentity.io: documentation, meant to be operated by a governance body

https://platform.humanidentity.io: example platform. You can signup in https://humanidentity.io and then login via oauth here

Basically every game server hosting provider bills monthly, but most players don't play all the time. So I'm building instalobby with a friend to provide to gamers on-demand hourly billed game servers.

We're starting with Valheim, but expanding to more games hopefully soon.

(If anybody wants to try we are offering $1 worth of credits to every new account)

The original idea came from repeatedly seeing the same workflow whenever someone wanted to expose an existing API to Claude, Cursor, or another agent:

* Parse an OpenAPI spec * Generate tools * Handle auth * Deploy an MCP server * Maintain it forever

I initially thought tool generation was the hard part.

After talking with developers, it seems the bigger challenges are authentication, permissions, endpoint selection, and safely exposing production APIs to AI agents.

MCPForge takes an OpenAPI spec or Postman collection and creates a hosted MCP endpoint. Recently, I've been spending more time on auth injection, tool permissions, and preventing destructive endpoints from being exposed by default than on generation itself.

Still very early (launched this week), and I'm mostly looking for feedback from people using MCP in production.

https://www.mcpforge.tech

Providing sandboxes through a CLI. Guardrails such as egress control and secret injection and audit trails built in.

We can also be used as 3rd party sandboxes in Anthropic managed agent and OpenAI sdk.

https://instavm.io/blog/self-hosting-claude-managed-agents-o...

https://twitter.com/gingerbeardman/status/206545782089234457...

https://bsky.app/profile/gingerbeardman.com/post/3mo42zcih4k...

https://mastodon.gamedev.place/@gingerbeardman/1167378688340...

https://www.inclusivecolors.com/

Most tools only let you enter a single color and then attempt to autogenerate or use AI to create the other tints/shades, which often don't do a great job and are really limiting when you're creating branded palettes.

The focus on this tool is to let you tweak every tint/shade while keeping an eye on accessible contrast. The curve based editor shows you how the H/S/L values of your colors vary across a color scale and is meant to make the editing process quick and intuitive enough that you won't want to give up control to autogeneration.

Part of this required that I manually parse a binary save file and extract the information. This was done through lots of trial and error and looking at other java implementations.

What I would have prefered is some sort of descriptor language that lets me generate the parser and interfaces for everything so I just drop the binary stream into a parse function and get my typed object back.

I'm working on creating a TypeSpec Library and Emitter for this so that you can describe everything in Typespec as to where and what is in the file and have it parse.

I think that's because time tracking is hard and annoying, that's why I made it "set and forget" instead of requiring a new habit.

https://donethat.ai

The problem I kept hitting with agent workflows (especially cloud hosted agents) was that the artifacts they produced became really awkward to handle across different cloud sessions.

So I built Artifacta as the boring storage layer underneath. Agents store and retrieve artifacts via CLI, REST API, Python SDK, or an MCP server. Artifacts are grouped by session/agent metadata, deduped on identical content, and safe to retry (idempotency keys), making it easy to handle artifacts across different sessions.

Would love any feedback for those who run mutli-agent orchestration or if you deal with artifacts across different agents.

In my living room I have a linux pc connected to my TV and I'm using this in 2 ways:

- Automatically set lights when media starts/stops playing. This way I can turn on some accent lighting when I pause a movie to go to the bathroom and automatically turn them off when I resume the movie

- When media is playing I calculate the color that best represents the content and export it to home assistant use it as a poor man 'ambilight' with a led strip strategically placed behind my TV

I think the next logical step is to find a way to automatically track the content I'm watching so I can have some high level stats about my viewing habits.

My current focus is adding support for signals, amongst other things: https://www.chrisarmstrong.dev/posts/ocgtk-development-updat...

[0] https://cybernetic.dev

[1] https://github.com/sveltejs/svelte/issues/17176

https://matchupnews.com/

I'm working on the filtering logic so she more easily find the posts she cares about

Currently, for 27 podcasts, the episodes are fetched the day they are released and are summarized in nested bullet points.

I still don't know if I should just keep adding more and more podcasts or if I should turn it into a real set of tools where users could, among other things, enter the link of a podcast episode and get it turned into bullet points.

Not sure if it's actually useful yet but here's some things you can do now:

- Categorize instant messages incoming from different platforms using your local ollama

- Use regexes to detect keywords

- Act as a bridge between multiple platforms

- Keep traces of deleted messages by relaying them somewhere

- Choose whether the connections go out from your machine or the proxies provided

- Supports authentication methods that may be against TOS (e.g user account as the bot for discord)

It still needs refining, for example it's not obvious yet how to use the app and the examples are outdated

https://github.com/vinhnx/VTCode > It's an open-source coding agent with LLM-native code understanding and robust shell safety. Supports multiple LLM providers with automatic failover and efficient context management.

Recently it just got the 500th tagged release. The project has been started since August 2025, and the coding agent VT Code itself I believe to be stable and ready to use. Thankfully, I got help from the community; recently, we pushed quite a lot of releases, enhancements, and bug fixes.

Over the years, I built a collection of scripts to speed up ad creation, testing, and campaign management. As generative AI improved, it became possible to automate much more of that workflow, and those scripts gradually evolved into a product.

The result is Zendux AI (https://zenduxai.com).

The idea is simple: instead of manually creating dozens of ads, users can generate different angles, messages, layouts, and formats from a single brief. They can then launch those ads on platforms like Meta Ads and automate parts of the testing process using rules and scheduled workflows, similar to cron jobs.

I've also been working on an open source protocol / reference implementation for user-owned AI memory, with the basic idea being that as applied AI scales, more products will derive more claims about users, teams and workflows from chats, docs, calendars, emails, etc, and they shouldn't be trapped inside of one product. Right now there's a lot of opinions on what shape memory should take internally, but I'm focused less on standardizing that part, and more focused on the primitives around it: requiring inspection, correction, revocation and treating portability as first-class. It's early but I'm starting to build more of a clear vision around it and would love feedback from anyone working on local-first software, personal data stores, capability security, knowledge graphs, etc. https://github.com/danielrmay/likewise

I also shipped Claudity, an experimental thinking partner plugin for Claude Code based on Microsoft's Clarity Agent framework/harness open-sourced last month. https://github.com/danielrmay/claudity https://github.com/microsoft/clarity-agent/

Lastly, I'm working on an homage/satire project to milliondollarhomepage.com as it's one of my favorite web phenomenons of all time.

Choose your genres (and more filters) and get auto updating playlists from your music library. Also just added a new feature - select a few (or one) playlists and create a "mirror", with tracks belonging to the artists of your selected playlists.

We are currently expanding the architectural drawings and structural analysis and also export formats. The goal is still to offer everyone in tropical countries the tools to understand their house construction before they go to meet professionals.

https://ghanahouseplanner.com/

What new ideas am I thinking about?

I'm pretty sure there are plenty of things left to discover about voronoi diagrams, but for the time being, I'm mainly exploring what's possible to build by using voronoi cells as voxels and devising various tools for cutting them.

Since they're convex polyhedra, almost any shape is possible (in principle, if not in practice) by combining several cells.

What I find particularily interesting is that a solid 3D world can emerge from just a collection of points arranged in different patterns.

https://jazzprogramming.itch.io/vorfract

- SophAI (https://www.sophai.app/): an app to connect the dots across cross-domain. As a CTO, I read across multiple domains (tech, design, business, e-com) and often have to connect the dots. I am building this primarily for myself. It is basically a rss parser with a big AI prompt to connect the dots across the blog posts. As I type this, I'm working on adding podcasts to the app.

- CTO field notes (https://www.ctofieldnotes.com/): collection of essays growing out of my 30 years in IT services. One essay every Tuesday.

Basically what would I want to see if Django shipped a queue backend like Rails did with Solid Queue?

https://github.com/coriocactus/dj_queue

In TableForge, the DM is agentic with access to tools strictly following 5e rules. The DM is responsible for narration and reacting to players but your character sheet, inventory, spells are all real server resources you manage. The DM can interact with them through deterministic 5e-based tools (dice rolls, damage, sheet updates, memory). Players can play in real time or async.

You can provide the DM a premise (or pick one from the library) and it'll flesh out a full campaign story arc. Either way it's a fresh story arc reacting to your actual decisions, every time.

[0] https://tableforge.gg/

One is Rad [0], a programming language tailored for writing CLI scripts and tools (mainly an alternative to Bash), taking a declarative approach to things like script arguments. Latest push has been largely on static type analysis, since making that really good is the sort of thing that helps both people and AI agents write good Rad.

Second project is Kan [2], a Kanban board which operates on text files on your machine, and is designed to be Git friendly so you can check it into your repo.

[1]

https://github.com/amterp/rad https://amterp.dev/rad

[2]

https://github.com/amterp/kan https://amterp.dev/kan

Continuing development of online training for software testers, with a heavy emphasis on AI, since that’s where the demand is.

During a livestreamed demo yesterday, I ran into a ridiculous bug in Copilot for Excel. After all these years Microsoft still can’t manage the basics of reliability and still deny that they need good testers.

One test stack on the platform been running entirely automated for months now to research, author, code, ship, and promote https//ainews.personastack.ai completely on its own. Many more things are possible like automatically identifying fixing, and shipping in response to 500 errors, personal assistants, or whatever you can come up with. I'm working on moving both my other open source projects over to be run by AI teams right now.

I plan to have a catalog of easy to deploy stack templates: https://personastack.ai/catalog/

Please register for an invite if you're interested!

“nub” is a good name because it can also be read as “noob”, which I am, when it comes to PL, type systems, and OS design. But I’m loving the deep connections that I am learning to draw across subjects like computability theory, functional programming, and brass-tacks software development.

For example, I find myself understanding the purpose of the borrow checker in Rust (“to make race conditions impossible” is my understanding: feel free to correct me / add color).

No website or GitHub repo yet. I’m brushing up on classical logic and learning Idris. Installed QEMU today.

https://www.novopathmedical.com/ - evidence-based guidance of diet, exercise, and mental health via SMS for end users. Clinician-guided feedback to bots.

https://github.com/rush86999/atom - ai agent workforce. Harder than expected. There are so many issues with sync with 3rd party apps. Need to launch the first one, so this is getting put on the back burner. landing page: https://atomagentos.com/

1. Kinetic Merge - it's a CLI tool for merging in Git repositories. What it gives over and above the core Git merge is the ability to merge through the motion of code from one location to another. Yes, Git can track file-renames and merge through them, but it doesn't follow code moving around inside a file, or a file being split into two or more pieces, or a new file accumulating code that used to live in several files. Essentially, the sort of thing you get with a lot of refactorings or automated code tidy-ups.

I've been at this since 2023; it was a long-standing itch I had to scratch since back in the early 2010s, finally got some time to work on it. Now in its 57th release, GitHub tells me!

It's written in Scala and packaged up as a standalone executable - needs a JVM >= 17 to run it on Linux / Windows / OSX.

(https://github.com/sageserpent-open/kineticMerge)

2. Americium - this is a mixed Java / Scala framework for folk who want to write property-based or generally parameterised tests, but: a) want the failing tests to shrink automatically without writing custom shrinkage logic and b) don't want to have the test structure and expectations DSL dictated to them by the framework.

Its job is to serve up test data into your flavour of Java or Scala test, look for an exception from the test and get shrinking. The rest is up to you.

There is a separately shipped artifact that plugs into JUnit5 / JUnit6 for a tighter integration, including test replay via IntelliJ or Visual Studio or whatnot, but that's an optional extra.

I've worked on this since 2020, now hitting its 52nd release. I use it for my other projects, and I know of a couple of corporate teams that use it because I evangelised it to them, but ironically, I'm only just getting round to using it for the problem that motivated me to write it in the first place.

(https://github.com/sageserpent-open/americium)

I recorded a quick walkthrough video here: https://www.youtube.com/watch?v=skK6xMJxttk

(if you want to join the beta, you can create an account for free: https://www.tnxapi.com/UI/CreateAccount.php I'd be happy to hear your feedback)

And more recently https://dartsva.com/ - a coach for playing darts. Has structured training routines. Mostly working on expanding content for SEO.

I am using all the code I produce and try to backport it on the UI component kit I have: https://chakrablocks.com/

If you want to try any project feel free to DM me. Will give access for free

https://feedbun.com - a browser extension that decodes food labels and recipes on any website for healthy eating, with science-backed research summaries and recommendations.

https://rizz.farm - a lead gen tool for Reddit that focuses on helping instead of selling, to build long-lasting organic traffic.

https://persumi.com - a blogging platform that turns articles into audio, and to showcase your different interests or "personas".

Took a long break earlier this year to recharge, but now I'm back at it again, mostly working on Feedbun, about to launch it as an early alpha. :)

https://blainehodder.github.io/shredlog/

- Imagined job I want to do: Teach software from the ground up, with good illustrations.

- Side: https://peace.mk/ - Create my own automation framework, because I want to make it clear what infrastructure-as-code is going to do before/during/after you run it

- side-side: https://azriel.im/disposition - a diagram generator like graphviz, but supports markdown, to visualise what infrastructure exists / will exist / will be deleted / is in progress when automation is running

- side-side-side: https://azriel.im/dioxus_codemirror - needed a code editor that supports LSP so manually creating diagrams is learnable

I'm back up the stack to the diagram generator, and hopefully soon back to the automation framework

And I plan to have more features like: time tracking, kanban, read later links, scripting etc, in the same simple interface.

The important part is, data is and will be stored in a single text file. No online interaction.

Right now you can

  - Take notes
  - Create to-do/mark them done
  - Organize notes/todo in projects or tags
  - Inline calculation using fend [1]
  - Powerful undo/redo
  - Archive notes that are not needed

Right now there is no demo version.

[1] [fend](https://printfn.github.io/fend/documentation/

I sometimes need to have a quick but realistic model of an optical system without paying a few thousand for some of the well known commercial offerings, so I've been building this.

It will include the correct name, absolute address, bit offset and width plus a bitfield description.

This is needed for bare metal coding (in any language) without using the massive monolithic systems from the manufacturers.

I've previously made a Mecrisp-Stellaris Forth Language Server as a test run and it works fine with helix editor.

https://github.com/techman00172/schematics/blob/main/mecrisp...

Currently working on some networking parts, because I want multiple exocomp instances to be able to cooperate in terms of knowledge sharing and workforce sharing. So I'm experimenting with websockets combined with multicast DNS-SD via UDP sockets. Might be kinda nice if I can make all services discoverable and plug and play. Also using DNS-SD for my llama.cpp wrapper already, which allows local model and inference service discovery quite nicely already.

[1] https://github.com/cookiengineer/exocomp

[2] https://github.com/cookiengineer/gooey

for example:

  // C++ (naive version, sorry)  
  vector<int> bin(vector<int>& x, vector<int>& y) {  
    vector<int> r;  
    for (int a:x) r.push_back(lower_bound(y.begin(),y.end(),a) - y.begin())  
    return r;  
  }



  # Jet  
  ord<<{x asc asc} # double grade idiom  
  bin<<{y,x ord drop len[y]-ord[x]-1}  

moreover, the C++ solution is O(m*log(n)) and jet is O(m+n) (though with a large constant factor) - but of course we can do much better once I implement it as a real builtin

Also working on a Claude Code launcher that allows easily swapping between 3rd party provider profiles: https://ccode.kronis.dev/

First, `aurgate`, a small AUR helper which is more barebones than alternatives but provides a "full diff" workflow. The idea is to make upgrades feel like a "full diff review" and also support graphical tools like meld or the vs code diff viewer.

Second, `flatgate`. This tool is inspired by LittleSnitch and Flatseal. Here the idea is to "default deny" all permissions of newly installed flatpaks and allow/whitelist per invocation (where possible) or on first use.

I also vibecoded/built https://github.com/lnenad/difiko as AI generates a lot of code that needs a nice way to review it.

I'm also in the process of preparing a soft release for http://logdot.io as the market has no access to low friction logging/observability platforms.

Not technically released even though the site is live, but close enough to a beta at this point.

https://phials.phoundry.app/

https://poser.pro.

At core it turned out to be a complex optimization problem and a real challenge to tackle. I also put a lot of care in the UI/UX, while I usually focus more on backend work. It's working well, I am just finalizing the handling of some of the nastier edge cases

https://www.jetlagcoach.com

Github: https://github.com/microsoft/accordant

Docs: https://microsoft.github.io/accordant

Every API has a contract - the rules for how it should behave. You can't withdraw more than the balance. You can't delete a resource with active references. You can't re-create what already exists. But usually these rules are never written down in one place. Accordant lets you write the contract directly, as executable code. Not documentation that drifts, but code - if the implementation stops behaving according to the contract, you get immediate failures. Not only can you use the executable spec to validate _arbitrary_ scenarios, you can also use the spec - a first class construct - to mechanically explore the state space of a system and generate interesting test sequences. The docs above have examples.

Also worth calling out that we've used the framework to model a number of complex, distributed real-world systems: those involving async processes, concurrency, retries and crash consistency. These are non-trivial specs (and they pair quite well with techniques like deterministic simulation testing). Great care has been taken to ensure the specs remain readable and concise despite that richness of behavior. For those of you old timers who might be familiar with Spec#/SpecExplorer and NModel, this model-based testing library is a descendant of that line of work.

With the rise in AI-assisted software development, I feel we need richer ways of specifying and validating software and I feel quite excited and bullish about the possibilities here. There's a lot more to say on the topic - follow my twitter feed if interested in more updates ;)

It's Agentic QA + auto-provisioning sandboxes. Makes it plug and play to do code reviews that actually run your code instead of looking at it really hard. B/c the agents control all of the environment (ie running all of the services), it's able to collect runtime evidence about pretty much everything.

A couple open source examples: (Excalidraw) https://app.ito.ai/share/d1cb1475-fbe5-4c71-901b-409ba2aa6d6... & (n8n) https://app.ito.ai/share/bb7d73aa-fd08-482d-9938-87938e2a232...

It started because I found myself opening a lot of different sites to get a quick picture of a domain. The main project right now is a domain security assessment tool that combines DNS, WHOIS, MX, SPF, DKIM, DMARC, DNSSEC, TLS/SSL, security headers, redirects, and other public metadata into a single report with findings and recommendations.

I've also been building out the smaller supporting tools around it as they come up in day-to-day IT work.

Still a work in progress, but I've been having fun building it.

https://swissarmytechtools.com/domain-intelligence-scanner/

I am also working on an iOS app for video.

With this framework, I'm making (among other things) an early literacy app at https://letterspractice.com. My aim here is to hit >= 75% efficacy of Mentava at <= 1% of the price.

The app is near to production readiness, and I'd be happy to share access now with anyone who has verbal but non-literate kids. Be in touch if interested at colin at letterspractice.com

The hinting system for it is a bit work in progress (trying to tune the difficulty and feedback from hints)

https://figarooo.com/

It's a CD tool for Kubernetes built on top of Flux and OpenKruise canary controller to bring a full end to end delivery on Kubernetes in a declarative way without the pipelines. Every stage of the delivery is just a composable component (health checks, smoke tests, schedules, environment promotions).

It's heavily inspired by https://aws.amazon.com/builders-library/automating-safe-hand... and Spinnaker.

My most recent piece is about the privacy-impacting plans the UK government announced this week, but my favourite recent output is an essay titled Care About What You Do, which brings together a lot of small thoughts I’ve had for years into a consistent thread.

More technically, have found some time in recent weeks to work on my site design backlog - most recently re-implementing inline newsletter signups after the email platform’s embedded widget broke.

If anyone has any SOTA show hn tips i'd really appreciate it.

This has been in the works for many years! The project originally started as web forms driving After Effects templates on a Windows server, and has now evolved to a point where the web technology landscape has matured enough to build a full-on motion graphics editor right in the browser, using WebGPU and WebCodecs.

You play a duck in a small shared town. You pick a job, pay rent, post on a Twitter-style feed, vote in local elections. The simulation keeps running when you close the tab. No PvP, no loot boxes, no combat. Playtime is a few minutes a day by design.

Similar to goodreads and other book clubs, but focuses on making logging pages and statistics around your reading more fun. Nudging friends when logging pages is the main motor behind this.

https://github.com/agentify-sh/gateway

There was a decent amount of work involved in getting the download size reasonable since we need to store all valid moves in a position. There are puzzles with over 40 million valid move sequences, so I had to aggressively prune and compress the move trees.

[1] https://apps.apple.com/us/app/one-million-checkmates/id67625...

After getting laid off a few weeks ago, I decided to give it a complete rewrite with some new features (offline support, lists, passkeys) and a new UI.

It's still very much a work in progress, but I'd really appreciate any feedback that could help make it useful for others as well.

On top of that, it's lead me down the rabbit hole of a 1995 (limited) theatrical movie called Mr. Payback, which may have only ever existed on 50 sets of laserdiscs distributed to those theaters. I'm hoping to track down a copy of it... if anyone had any clues on that one, I'd love to hear them. I'd purchase a Domesday Dupe device and dump it. But it may be a genuine lost movie.

Started as a spreadsheet, moved to notion database, now a web app. Idea is groups have collective libraries across members, and planning what to play when is a pain.

Tried to make it easy to get going - take photo of your games shelf and we identify the games there, look them up via the BoardGameGeek API and add the to you library, then you can the pool with others.

It's free if you want to give it a go:

https://ourboardgames.com

When people deploy python and perl code, they have to either export their entire environment, or build a container. The latter is not possible in a number of deployment cases, and the former carries all manner of dependency radius gotchas.

So I am building (ok, I am prompting/testing/reviewing, the agent is doing the heavy lift) compilers for each of python 3.14.x [1] right now, and perl 5.42.x [2], that can generate static code.

Early stages, perlc does work well, pyc is a work in progress.

[1] https://github.com/joelandman/pyc

[2] https://github.com/joelandman/perlc

It’s using a local YOLO detector trained specifically on detection pdf page regions.

https://www.appblit.com/pdfreflow

The old version works and has many users who love it to read scientific papers, but its heuristics based and was in my opinion failing on edge cases that this new AI approach solves.

[1] https://apps.apple.com/us/app/reflect-track-anything/id64638...

PAX is the easiest ERP to pick up. Our core idea is that ERP should not take weeks of formal training and implementation. We have no formal training, no implementation fees, and are a complete ERP+CRM GAAP accounting system. It's intuitive, well-documented, AI-assisted (never steered), and people can pick it up and start using it well with no questions to our team.

There are also technologies new-ish to this kind of site included like every thread is a live thread via websockets, your post and comment scores update in realtime, notifications are realtime, you can DM other users and receive your messages immediately. So it's distinct from the everything is a hard page load world of 10 years ago and blurring into native software in a browser.

What I'm working on right now is a SwiftUI iOS app, because one of the most interesting observations from analytics has been that the internet is 70-80% mobile devices now, contrary to my 10 years out-of-date conception that people were mostly using the internet on desktops. So a mobile app seems non-negotiable to reach most users. I have a PWA already, but early users have repeatedly requested an official App/Play Store presence.

The stack is somewhat unique in that it's built with a Swift/Vapor framework (https://vapor.codes/) backend, with a more standard React Router 7 (SSR) frontend. I picked this framework mostly because I'm historically an iOS dev, but have found it to be very capable in its own right. I later discovered Apple themselves are using Vapor for some web services and have a team devoted to maintaining the server library (SwiftNIO https://github.com/apple/swift-nio) the framework is based on.

Anyway, it's very early still with launch via Reddit itself only 3 months ago. One of the biggest issues is getting it in front of people without appearing spammy and cold-start on a social platform is also brutal, you need users to get users, and round and round it goes. I may do a Show HN in the future if there's any interest in a real experience using Vapor as a production backend.

https://github.com/jpfaraco/muy

I've been building this little animation tool I’ve wanted for years, inspired by one of Bret Victor’s demos from his talk “Inventing on Principle”. I wrote about it here [1].

Basically, instead of setting keyframes and tweens, you perform animations in real time: select a layer, manipulate its properties and the timeline records every frame.

No install, no account needed. It's like Excalidraw, for animation.

I still have some ideas and hope to keep evolving it. And I hope other people find it useful for making neat videos.

[1] https://joaofaraco.com.br/en/projects/muy/

https://www.givedirection.com

Just getting started really and you can see a bunch of the stuff I post every week on our Youtube:

https://www.youtube.com/@givedirection

It’s going really well so far in the second month, to the point where I now have an advanced class and some possible organizations lined up that want me to help to train their staff.

I need to fill up my classes or get org contracts so tell who you know.

The cool thing also now is that we have a small community of builders in the discord that have shipped so it’s good to see people working together.

I feel like even after all these years we’re still missing the devex that Heroku provided.

Canine basically wraps a Kubernetes cluster -- gives you a heroku like interface to deploy applications to. At some point, if you get big enough that canine is no longer powerful enough, you can just "eject" canine from kubernetes, and continue using kubernetes directly, without having to do any migrations.

Just passed about 2000 developers, at this point most of my work is resolving bug fixes, adding helper text everywhere to make things cleaner, and supporting setups I've never encountered like homelabs with changing IP's

After working a bunch on logic puzzle Ruly [0] which is now in a steady state and visited daily by a small group of users, I've begun a new puzzle based on the relative positions of cities, towns, landmarks, and points of interest in my native Yorkshire (likely to be followed by other territories).

I'm experimenting with different ways of using Openstreetmap data to make something that tests local knowledge in novel and interesting ways. Working title: Where the Heck? An initial prototype will be ready soon.

[0] https://playruly.com

The service is composed of two open-source services, namely a Nextcloud app (Astrolabe) and backend (nextcloud-mcp-server). I use the service as an MCP server across a number of apps, and others use it primarily for semantic search over large numbers of documents.

Both are open source, and I'm working on a managed offering, completely based in the EU, for individuals/teams that already use Nextcloud and want to be able to use semantic search across some or all of their documents.

Essentially your data stays in Nextcloud, and the MCP server backend keeps a vectordb in sync to enable semantic queries over your content. The number of supported apps is growing, including:

- notes

- deck cards

- files

- news items (RSS feeds)

- cookbook recipes

- contacts & calendar

And I'm adding support for other apps as I go.

https://www.riq.net.br/pub/colorscience/

https://www.metanoia-research.com/dispatch-004-up-from-the-a...

https://functionalprogrammingstrategies.com/

I'm currently writing up what is the last major chapter, which introduces capability-passing as an architecture, and builds a simple TUI framework using it. Fun stuff!

I'm a few months away from launching the book, but the early feedback is very positive. I find writing enjoyable but also, damn, do I need to get this book finished. :-)

It is an open-source project and I will introduce soon its mcp/cli counterpart so that graphical context and sumaries can be given to LLMs/Agents directly through the mcp integration.

https://github.com/devlensio/devlensOSS https://devlens.io

- https://kanmail.io - always plugging away at Kanmail changes, no one uses it really except me but that’s fine :) new site designed by fable blew my mind

- https://verified.fyi - first side project started initially as a vibe coding experiment, but it’s become quite good at sussing out dodgy websites

- https://bgpipe.org/stages/aspa/

- https://www.ripe.net/manage-ips-and-asns/resource-management...

A worked on a 3d asset generator with nodes (like Blender/Houdini)

https://greggman.github.io/sedon/

I worked on a couple of design generators

https://github.com/greggman/design-new-tab-page/

https://github.com/greggman/gdp-gen/

A very simple idea: when you eat more than your maintenance calories, you gain weight; when you eat less than your maintenance calories, you lose weight.

By using an algorithm, we can accurately figure out your maintenance calories more accurately than traditional regression based formulas like katch mc ardle.

It's way more accurate than calorie burn tracking devices like fitness bands and watches. (garmin/apple watch etc...)

MacroCodex helps you spot dips in maintenance calories from metabolic adaptation, then auto adjusts your calorie target and macros so your plan stays aligned with your real maintenance calories (TDEE).

It's very useful to those who find it hard to gain or lose weight.

it's a completely free app, no paywall, no unnecessary data collection.

Already reached 13,000+ users

Those of you who are new to this, Qawwali is predominantly south asian genre that is centuries old. My goal with this website is more like wiki, or a gateway for anyone wanting to get introduced to the genre. One of the main, and the complex feature that i worked on was building family trees/lineages. https://www.qavvali.com/

https://www.squire.games

I've been an on off off tabletop wargamer for ~ 9 years and have never been really happy with the options for list building, game tracking etc. Everything was very clunky, slow and disjointed. I came up with a product idea and brand logo but never had time to even touch it until recently.

It's still very early days, but I'm starting to test drive it out and loving it so far. Lots more to do, but would love feedback from anyone that wants to give it a whirl!

A contracts management platform for the events industry in Brazil. WhatsApp has turned communications chaotic between vendors and customers across the event's lifecycle. Both parties suffer from not having a single version of the truth about what is promised to the event. The product helps in that sense.

A human capital platform that helps companies comply with Brazilian labor laws in regards to time control via punch clocks. It also helps managing contractors and freelancers.

Looking for a publisher to my first book "The Least You Must Know About Computers to be Free". A sci-fi technical novel about open hardware, FOSS, cryptography, AI and Bitcoin. It aims at teens and young adults.

Raising my two teenage children. (hardest project)

2 person team and we didn't do anything manually beside creating the entity relationship, and briefly documenting the overall design system we wanted. Now we are sitting on an almost 80% completed system with 6 more months in hand.

I’m doing composable and dynamic global profiles which are selected based on what you’re doing.

https://github.com/elleryfamilia/rosita

Voiden: Released the Voiden Runner so that users can test APIs directly in the terminal. https://github.com/VoidenHQ/voiden

ApyHub: https://apyhub.com/ working to onboard a few more API providers. Working to rationalize the terms for new APIs added in the catalog.

I am also working to streamline how all APIs are certified and monitored.

So last 1.5 years i slowly built a web admin + ios app that has all the same functionality but with the concept of coaching yourself or others. Got some interest from coworkers and friends so trying to make it into a saas and launch after summer.

https://www.strengthara.com/

The idea: dynamic + minimal syntax for scripting, but you get a single static binary and Go's concurrency primitives (goroutines/channels) for free. No runtime to ship, easy to deploy anywhere.

Intentionally few features, the goal is small and scriptable. Someone with programming experience should be able to pick it up in half an hour.

Still very early stage.

https://github.com/aisk/goblin

https://github.com/brettkoonce/lean4-mlir

Now we’re working on effective utopianism and specifically on physicalized computational ethics to intrinsically align all AI agents: https://effectiveutopia.org

For the list of startup ideas with mockups: https://ideas.uto.now

I'm also reading Principles and Practice of Deep Representation Learning, Or: A Mathematical Theory of Memory.

The last few months I’ve been reading a lot about neuroscience behind learning and practicing music and I’m fascinated by the subject. It has helped me realise why the app works for me, as well as my own mistakes that held back my progress for many years despite putting in decent efforts.

It was a much needed inspiration to continue working on it with a re-evaluated roadmap.

I recently wrote a blog post about it - https://www.captrice.io/blog/what-makes-captrice-work.html

[0] https://www.retrodev.com/blastem/

Strictly human content, pagination instead of endless feeds, one-off payments instead of subscriptions, linear feed by default, public profile scoring instead of secretive algorithms.

Hope to share it soon around here, too.

1. https://interauth.dev/

Share a single google doc with your agent (w/o oauth mess)

I needed a way to share a single google doc/sheet with my agent

I didn’t want to go through the heavy oauth gcp project so I’m using disposable email addresses as the work around

2. Agents.sh

I get so many cold emails that could be better if I tell the bots how to talk to and reach me. What’s top of mind for me, how I like to be pitched, etc.

So I made a mini platform to put up text/md files. Then added all the perms fun - pw support, expiration, every url has an inbox. Aimed at agents only.

Ex: https://agnts.sh/greg

- vibesurfer (https://github.com/frane/vibesurfer): a web browser for agents, without Chromium and CDP.

- agented (https://github.com/frane/agented): a “text editor” for agents, with undo, state, and LSP support.

- grpvn (https://github.com/frane/grpvn): a local chat for your local agent and LLMs.

https://rezgen.app

It is currently in review with Apple and will be coming to the iPad and iPhone. This is an iPad-first dungeons & dragons app focused on empowering dungeon master's as they manage their campaign. inspired by my first DM in my first campaign with friends.

its been fun to hack on :)

TestFlight here for anyone curious! https://testflight.apple.com/join/kM4udJSZ

Been doing this to improve/simplify the grammar for Trilogy[1], a streamlined SQL language - I’ve been planning a redo of one feature and it’s nice to be able to rapidly get feedback on various syntax success rates. Also been particularly useful to optimize error messages, which should help people too.

[1] https://trilogydata.dev/

https://github.com/gethopp/hopp

It's an app that allows you to schedule a wake-up call and get a real call from a friendly person, somewhere in the world. No phone numbers exchanged. All calls happen through VoIP in the app.