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!

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.

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.

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.

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

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

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

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.

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

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.

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

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.

---

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

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.

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.

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

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.

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

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

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

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

https://hackylabs.com

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

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

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

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/

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

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.

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.

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

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.

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/

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

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

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

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.

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

* Users are given a prompt and have 2 minutes to answer.

* Speeches are reviewed by AI and other users.

Speaking eloquently "off the dome" is an incredibly useful skill, improving all your interactions with other people. And like a muscle, you can train it with dedicated practice until it becomes effortless.

It has been very fulfilling to listen to other people's speeches, knowing that we're helping each other pursue our shared goal of becoming excellent communicators.

If you're looking to improve your public speaking, I recommend you give it a try!

https://apps.apple.com/il/app/orate-practice-speaking/id6761...

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

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

https://locallane.ai

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

https://soberstack.app/

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.

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.

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/

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!

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.

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.

Website: https://PuzzleLair.com

- https://homail.shanehoban.com - resend clone (transactional emails)

- https://mindmap.shanehoban.com - my canvas note taking app

- https://bnb.shanehoban.com - my airbnb for family use

- https://hsk.shanehoban.com - the starter-kit I made for making these apps (available on github: https://github.com/shanehoban/ho-starter-kit)

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

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

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

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

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

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.

(I also made my own implementation of DER, which I already use for some things that are unrelated to X.509, such as a game engine, and some other stuff where a structured data format would be helpful. So, it includes some types which are not used in X.509.)

- 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

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

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

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

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

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.

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

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

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

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.

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.

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

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.

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

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

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.

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.

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)

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

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.

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

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

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/

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

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.

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.

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.

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

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.

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

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/

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

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:(

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

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.

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.

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

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.

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

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

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!

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)

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

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

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!

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.

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.

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.

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

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://croncoco.io

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.

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.

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

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.

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

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

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)

I recently wrote a blog post using Min Hashing to estimate that at least 90% of the 1.17 petabyte dataset are duplicates and I keep investigating new ways of making this dataset manageable. https://www.felixhaba.com/writing/simplifying-healthcare-pri...

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

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

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

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

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/

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

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.

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.

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

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

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

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!

World Cup schedule with no spoilers. Where you can save the teams you follow and make cal events for upcoming matches.

https://worldcup26-schedule.pages.dev/

A tech events listing page for New Zealand. Where approved organisers can freely post upcoming events and people can subscribe to hear of new events.

https://techevents.co.nz

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

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.

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.

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

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)

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.

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

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/

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

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

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.

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

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.

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.

[0] https://cybernetic.dev

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

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/

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

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)

https://matchupnews.com/

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

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.

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.

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.

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.

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.

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.

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

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

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

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

- 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

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

https://phials.phoundry.app/

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

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

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/

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/

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

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.

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

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

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

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

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

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

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 ;)

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.

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!

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.

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

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://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. :)

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

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

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 :)

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

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.

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.

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

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/

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

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

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.

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

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

https://poser.pro.

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.

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/

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.

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

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/

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/

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

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

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

I am also working on an iOS app for video.

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.

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

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

https://github.com/elleryfamilia/rosita

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

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.

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)

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

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.

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.

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

https://github.com/Aquithm/hyperplane

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.

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/

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

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.

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)

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.

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

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

NextBunny is a visual development platform for product builders.One system to go from idea → design → production. No Handoffs. No tool switching. Full control.Perfect for Next.js and React apps.

Modern and affordable Figma,Framer alternative but without hype or lock in.

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/

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.

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

https://bedtimebookhelper.com/

In the mean time, I’m working on a recipe application I’ve had countless false starts on. It’s centered around iterations and version on recipes, tracking changes to ingredients and directions to build new a new recipe from an existing one.

I’m starting with a go Bubbletea tui this time and I’ve been having a lot of fun with it compared to the React SPAs I’ve tried before. Not feeling compelled to style anything while working on the UX has been nice.

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

https://nicolasbouliane.com/recipes/holunder-syrup

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.

- 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

It’s a small board with a ATtiny1616 and motor driver that mounts to the bottom of Behringer MF60T replacement faders and provides an I2C interface for reading the position, moving to a specific spot, and even setting up haptic detents, like a linear version of my SmartKnob project.

Perfect for making an intuitive smart light dimmer switch or a macropad.

Just need to find some time to finish making a proper video about it…

https://github.com/scottbez1/FaderBuddy

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

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

It's a durable orchestration loop for implementing code with LLMs that forces review and verification gates until the code matches exactly what you asked for.

It's complementary to any existing harness or tools you use, you investigate and plan your work and simply have your agent hand off the implementation to the engine.

You can have Opus 4.8 implementing, GPT 5.5 and DeepSeek reviewing in different roles etc, mix and match however you like.

It also supports sandboxing out of the box, starting with the YC backed Microsandbox.

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.

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!

This week we're working on a modular WASM build to allow others to embed Tritium directly into their own platforms. AI native startup law firms love it.

https://tritium.legal

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.

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

https://figarooo.com/

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

Today I caused thermal runaway on a BLE thermal (sic!) printer. That melted half of its components together before I noticed. The fun fact is you can do that witouth authorizing, as long as printer is turned on "poof".

Now I'm trying to figure out a BT protocol if DJI Power station, so I can read and track its metrics.

I wrote an improved driver'ish for cheap 5G modem recently. I've been on the last 5% stretch for few months lol.

And I started reverse engineering my LandRover OBD/CAN stuff, so I have some data to publish for other hakers.

https://www.kickstarter.com/projects/taikohub/taiko-01-keybo...

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.

screen.cam records your Mac and turns it into a polished video. Smart zooms follow your cursor. Filler words come out automatically. AI-assisted YouTube uploads.

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.

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://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. :-)

I’m prioritizing user experience and QoL features, I’d like to build something calming and user friendly.

I recently added support for user generated puzzles - here’s a nonogram that I drew just now[2].

[1]: https://lab174.com/nonoverse/

[2]: https://lab174.com/nonoverse/play/custom/N4IgbiBcCMA0IGcogHR...

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

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

Hallways (https://hallways.lonnycorp.com) - a web browser for 3D spaces, where instead of hyperlinks you have portals that you can seamlessly walk through

LonnyMQ (https://lonnymq.lonnycorp.com) - a performant, production-ready TS PostgreSQL message queue library and accompanying blog post that walks through its design (of which I'm quite proud of)

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!

[1] https://hyperclast.com/ - open, fast, self-hostable replacement for Notion

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.

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/

It’s a complete redesign from scratch that combines Mac and Windows into a single codebase via Dioxus (right now they’re two completely separate codebases).

Existing app is at https://www.digitalrebellion.com/posthaste

I'm also rebuilding an integrated task/knowledge/publication system I'd previously built atop Gemini's Gemtext format. While I loved the simplicity, I've discovered that there are lots of burrs in that design, especially on the publication side, which I'd be able to lift by using a more fully featured document format like Djot.

It's a web-based game for 1-8 players, features a tutorial and bots, plays like a board game, and operates with economy, bluffing, forward-planning, risk-taking, course-correcting mechanics.

Play as an amateur psychic navigating a fictional stock market. Receive premonitions, call in your wizard friend, navigate dividends & earnings releases, and chase the glamorous annual investor awards.

https://splat-3d.com

Currently in beta, working out some pipeline optimizations. Looking for people to test! Feel free to try it out, join the discord, etc. Looking for feedback on the experience, reliability, etc.

The goal is for folks to be able to tune their own pipelines, right now I am working on adding more API params/knobs. Looking to build a good capture guide too, since most folks struggle with capture IMO

The idea is simple: Its handle of the complexity for AIOps infra like GPU VM provisioning, NVIDIA driver setup, Docker setup, model download, and launching the inference server. User can run any OSS and AI tools inside their cloud.

website + video demo: https://www.dagploy.com github : https://github.com/dagploy/dax

Website: https://www.asfaload.com/

Code: https://github.com/asfaload/asfaload

https://trustedrouter.com/

I made my own firmware for the little AI assistant esp32s3 AI balls you can buy from Ali Express. https://www.aliexpress.com/item/1005008627679270.html

Made a version of Infocom adventure frotz player to work with voice control on the AI ball so I can play Planetfall using voice control.

Made a toast alerter for Linux terminal command line.

Made a thing to alert you when someone signs in to a Linux server.

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.

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

- https://altitag.com: A real estate photographer can upload a drone photo and get points of interest pins overlaid on the photo using EXIF data. The annotations help provide some nice neighborhood context without needing to open up Photoshop.

As a side project I‘m building a multi agent harness that works across desktop and mobile and solves the issue of drowning in too many agent sessions for my own workflow. Hopefully I’ll open source it soon. Reach out if you’d like to beta test it. (Email in my profile)

https://www.codako.org/

  * Robotics Hello World: Objective is to implement ACT model to train my arm robot on simple pick-and-place tasks. Leaning heavily on HuggingFace's LeRobot library, but stopping short of using their model implementation and training loop. https://github.com/avilay/learn-robotics

  * Designing a new programming language: This is when I want to escape the annoyances of coding in Python and start daydreaming about a new language :-) https://github.com/avilay/kulfi

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/rumca-js/awesome-database-feeds - list of RSS sources

- https://github.com/rumca-js/Internet-Places-Database - list of domains

- native library to build TUI apps without the 20-60MB bloat of node/bun/go

- terminal coding agent harness focused on orchestration/loops

- a small scripting language that looks like JSX but has signals and render optimizations built in

- open-source software and hardware smart doorbell for a community space

- teaching AI how to write games for the Nintendo Wii

- designing an arcade cabinet

All of this over the past 4-5 months. AI is allowing me to deploy my short attention span very effectively! This is more than all I’ve accomplished in the past five years.

The main target users are lawyers who redlines and drafts legal documents, and they almost always use docx.

It can be used together with Claude For Legal; The combination is pretty magical.

Here's the plugin: https://github.com/LegalRabbit-AI/legalrabbit-docx-claude-pl...

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

I have a mailing list for when I launch and some local makers in Portland are interested so I'm hopeful.

https://flopper.io

Aside from that, I've launched a new tool that tries to promote Solar panels. The UK has some of the most expensive energy in the world, so I've been trying to let homeowners and building managers understand if their building's are suitable.

Uses some APIs all plugged together - including the DEFRA datasets for DSM (LiDAR from planes).

https://solarable.org

The idea is decompile something like Wordperfect or Framemaker, then port the NeXTStep code to GNUStep and have WP on GNUStep/Linux.

Basically, build anything using your agent of choice (Claude Code, Codex, etc) and get it live in your company's infra without having to provision anything yourself / loop in a DevOps person.

App goes behind company auth (e.g. SSO), and everything's handled for you: custom domains, governed storage APIs, observability, analytics, role-based access control, etc.

Private Alpha atm.

https://railcode.dev/

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

https://toge.app

The idea is to handle the whole thing, from meeting up at the start point, to multi-day trips, gas stops automagically planned in where you need them.

iOS only right now, Android support is planned but not a priority.

It's a bit of a passion project, as it solves a bit of a "personal" problem, I realize its niche.

I am also not a software engineer, but a DevOps engineer, so it's _entirely_ written by Claude in Swift + Swift UI, Typescript for the backend.

• A visual moodboard and notes app that uses local models to link and surface content, a bit like an AI powered Memex.

• A new UI design tool for Mac/iOS with deep support for design systems and AI agents.

• A CMS and static site generator that runs entirely in the browser. Download the site as a zip or publish directly to GitHub/Netlify.

https://github.com/sparktype-project/sparktype

TUI based interface to search in your files very quickly. I created it from the need to have an equivalent of voidtool's Everything on Linux. It's a bit different though because it's keyboard based. You define zones where you search for files most of the time, and you can manage previous files history. Then there are actions you can perform on each file/folder.

going fine, good reviews + average playtime isn't bad at all for only a demo, but it's frustrating to just struggle to get eyes on it.

https://fata.dev

https://github.com/Fingel/gelly

Also built out a .fits parser that uses rayon to decompress in parallel making it about 5x faster than cfitsio.

https://www.pedaldrivenprogramming.com/2026/06/8x-faster-fit...

Should be able to turn the computer off at the mains half way through, then restart and instantly carry on without any loading phase as if nothing had happened.

Well that's the dream.

Now the lower layers work I'm mapping out the actual ECS part and what the API will be like.

I'm quite enjoying it and it's a really fun challenge.

https://rezgen.app

1. Helping to make ActivityPods apps working on top of https://nextgraph.org/ (instead of SOLID).

2. https://cloudywithachanceoflatency.net, network monitoring done right (according to me), for humans and AI SREs (still WIP but quite fun already).

And when I get a chance, accepting some small paying contracts to pay bills. Weird times.

https://github.com/gethopp/hopp

The project is currently 100% vibe coded with codex\gpt-5.5, but after running some experiments, I'm working on replacing some of the vibe coded SQL engine with Apache Calcite.

https://github.com/coldentry/Specter

[1] https://youtu.be/kSyE4aoNthE

in the process, figuring out some tricks for getting opus to work with 3d a bit better

two tricks ive found is to:

1. get claude to present all the orientations to you, then pick which one after 2. convert 3d problems to 2d ones - get it to draw streamlines describing the geometry, rather than trying to look at the whole thing in 3d

fable was a fair bit better at working in 3d than opus is. well, opus mostly isnt

And been working on a Mario-with-guns game concept: http://devz.cl/posts/what-if-mario-had-a-gun/

Thought it’d be a short concept to get from start to finish but the things you need to implement and plan for in a video game can be near infinite and decision paralysis is a real problem for me.

I did expose some interesting stats which you can find here: https://tempmaildetector.com/temp-mail-market-share

edit: ah, yes also a broker controlled component manager that can start, stop, monitor services over the mentioned broker. This is the carpet that brings the room together.

https://github.com/RivoLink/leaf

You can try the game here: https://daily.gametje.com

Also working on a multiplayer version of the same game.

One thing I've learned is how hard it is to get things perfectly aligned.

I've been balancing ~800 player cards and running several simulations to balance the cards. It's been an interesting mix of my hobbies such as football, game design, many spreadsheets and CSVs, and a bit of code.

https://gemugami.itch.io/football-stars-2026

You have your mum's birthday, give you a heads up on buying a gift or booking a restaurant.

I'm now enrolling people on testflight: https://heylife.ai

Wrote up more details at https://openrun.dev/blog/service-binding/

A chat platform for founders, creators, and small teams to talk directly to their users! No more email or ticket queues. Build a real community around what you make.

I built this because I've seen firsthand how community Discords just don't scale for support or community-driven product growth.

Would love your feedback if you try it out.

https://video-commander.com

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

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

https://store.steampowered.com/app/4069810/VERDURE/

It's a visual way of setting up AI agents, so that you can have a quick overview over your automated workflows. Understanding where it might be wrong, as opposed to a personal AI assistant which can be a bit of a blackbox.

Everything has been built with Claude, even the bill of materials for the hardware.

The project is open source and now protects my raspberries. You can see a demo here: https://www.reddit.com/r/ClaudeAI/comments/1u03rja/automated...

Drift (https://github.com/Scope-Creep-Labs/drift) - a prompt driven control plane for time-series systems and edge fleets.

https://pdfbolt.com

It’s for the boring pdf jobs every SaaS eventually gets: invoices, reports, certificates, contracts, labels, that kind of thing. You send html, a url, or a template with JSON data, and get a PDF back.

Last week we shipped the Node SDK. Right now I’m working on the Python SDK and tightening up the docs

It's an aggregator for fanfiction and web fiction. Planning on adding some Reddit like and social features.

It sends me an email once a story hits a certain number of upvotes per minute, so it's useful for keeping track of breaking news.

It'll also soon allow you to get alerted to specific words or phrases in titles. (I have one set up so the monthly hiring threads notify me as soon as they appear.)

https://hnalerts.com

It's called Vocast: https://github.com/cnrmurphy/vocast

Thinking about adding some things like queuing RSS feed items to be converted to audio and a feature for being able to do the conversion from my phone.

It's an all-in-one, open source blogging/site analytics/newsletter platform that takes privacy seriously and is priced affordably (plus a free plan, obvs). Would love your feedback if you have a few mins to spare.

The goal is to make you write more!

https://pagecord.com

Surface syntax is mostly SML-1997-ish, but underneath it's a different thing: simple-sub type inference, algebraic effects, modular implicits, and Perceus-style reference counting instead of a tracing GC.

The compiler is currently a Rust frontend -> Zig codegen -> native binary pipeline.

Its been a lot of fun thus far.

Agents develop genuine perspectives.

Teams develop genuine collective intelligence.

Check out the repo: https://github.com/inthepond/each-mind

https://aptakube.com/

1) Local hosted https://app.localmail.uk/ 2) Security guard android app 3) Fall detector android app

https://site.localmail.uk/

The sites are AI generated and are a bit OTT and slightly inaccurate, but think of it like reading a comic...

Started from scratch and we are now fully interconnected with 2 MNOs and in production. With Voice, Data, SMS, USSD and other VAS working for our first client.

I'll be posting a Show HN soon, but the idea is to let the communities around GitHub repos fund the specific issues they care about while giving the maintainers of said repos agents of their choice to work on them (that they control entirely).

https://github.com/tarzasai/StreamCondor

- Loaders/Spinners should be fun - https://github.com/p-raj/pixi-loader

I'm also hardening my development virtual machine system. Properly firewalling it so that it can reach WAN but not the host or the LAN.

and I'm also working on a tool to allow runners to easily share their running gear kits with others https://grwm.run

I was working a lot on it recently...

https://ferron.sh/blog/ferron-3-0-0-beta-2-released

https://brodlist.com

It started out as a project to try Fable. It wrote a lot of the code and I am learning as I go. I am still questioning some of the design choices but so far it is working. I do want to improve it, so any feedback is welcome.

Recently made a stargazing app on Apple Watch, vanity address miner, playing with gameboy roms, and have been making and testing a social photo game that I’ll hopefully make public next month as a PWA

And the feedback dashboard I always wished existed, with plenty of integrations, low pricing, prioritization + clustering, and auto-PRs

https://usero.io

It takes your instructions, write a versioned spec, then generates a hybrid workflow of code+LLM calls and protects it with tests/evals

The result is that the agents run much faster (90% of it is code), cheaper (LLM steps are scoped tightly and uses smaller models) and reliably (specs get turned into coded state-machine)

Coming soon is a full automated training system to "certify" people to time events.

It'll spin up a VM with our timing software and an emulator of the hardware of your chosing and you kind of play a game to get certified (you deal with real radio traffic, real world like scenarios where shit goes wrong)... This way we don't have to train people AT events from zero.

https://peppy.bot/

It let's developer do test planning and testing automation using their coding agents. The records of the testing sessions are then shareable and can be added to PRs, giving the reviewers visibility into how the feature works, what scenarios are handled and tested and what might have been missed.

https://store.steampowered.com/app/4810350/Medusas_Gaze/?bet...

Created with 0 AI assets

Our vision is to replace resumes with a richer, holistic interpretation of a person's achievements by allowing them to talk about their experience and using that as a base for how they are represented.

There's a couple of other ideas I'm integrating right now, like a kanban view for your emails

It's silly and useless but I'm having fun.

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

hack music

https://www.dugoutmetrics.com

https://whimsy.numeracode.com, Happy to answer any questions any of you have

- https://news.ycombinator.com/item?id=48538174

- https://bztsrc.gitlab.io/skrellm/

It works well for me so far and I’m pretty happy with it!

https://github.com/cckolon/rlox

[0] https://craftinginterpreters.com/

In the odd times working on my workout app, which now has agentic chat, analysis, charting abilities, workout proposals and whatnot.

https://cotect.dev

It's a fast code inspector for agents so that you can easily verify changes before they end up on GitHub and also quickly move around the codebase to keep its shape in your head (to make sure your prompts stay high-signal).

I also just posted a new blog post on trash valorisation: https://stefan.schueller.net/posts/kva-winterthur/

Built with Opus and finished with Fable before the model was pulled away.

https://github.com/JuanDAlvarado/vilya

HTML/artifact canvases have a lot of potential

https://x.com/backnotprop/status/2064951065439834378?s=20

https://x.com/backnotprop/status/2065436433985474726?s=20

https://github.com/plannotator/effective-html

Shared context workspaces are important

https://plannotator.ai/workspaces/

https://github.com/plannotator/tot

https://github.com/TomerAberbach/profiler-md

Currently working on a diffing feature to compare before vs after profiles.

It also comes with a skill to have a coding agent profile and optimize your code!

Modules are simply folders, and the tool just reads from stdio and outputs to stdout. Runs are stored in simple text files with all the info of inputs, outputs and other metadata.

https://github.com/vichoiglesias/kern

I've never worked on android/iOS and I know very little about sensors. I'm trying to learn through this experiment. If I can get rid of Strava and some other apps along the way with a simpler core that would be fun.

https://leetarxiv.substack.com/p/why-compilers-rarely-use-st...

https://github.com/Kapperchino/agent-joe

https://github.com/agup792/Product-Management-Operating-Syst...

https://bibinmathew.com/neubook

Developed for my personal use but publicly available and open source. I’m pretty happy with the current state so don’t expect a lot of updates and features, but hopefully others might find it helpful.

No real use case in mind. Just a project that made me happy for a couple of weekends.

https://openstint.org/ -- https://github.com/zsellera/openstint

It currently exists of 12 libraries/tool, most of which are pretty stable by now, though some are still very much in flux.

This is one of those things that turns out to be kind of a lot of work. :-)

It's like the love child of Polytopia and Conductor. As many other agent management platforms/harnesses, Viberia has been building itself, and honestly this has been too much fun to stop.

https://github.com/Borderless360/django-logic

https://kastanj.ch/en?mid=hn 48528779

I have been working on it for a few years. Unfortunately it is currently put on pause, possibly for the entire 2026, but it will launch, and it will be a really useful tool for those that need something like this. I am very hopeful

The demo is available, no account required if anyone wants to check it out :)

https://gooblings.icdtea.com

And on a new post about how to design web apps for the AI-era for my blog: https://mliezun.com

it's all free, open source, and local-first. you can get a hobbyist tier plaid account and sync your accounts, or use csvs. rules-based categorization, spending trends, FIRE/savings-rate health view, etc.

there's also an mcp server so you can hook it up to claude/cursor and just chat about your finances. and a "canvas" feature where you describe a financial question and an agent builds you a custom calculator for it (e.g. amortization, compounding, what-ifs).

honestly it has all the features i want so i'm not sure what's next. i have a few contributors, always welcoming more.

https://github.com/tomfunk/fungible

[0] https://legacygenetics.org

I'm building a quick and clear search across all of them plus, I believe uniquely, their regulatory filing PDFs and websites.

https://opencharities.uk

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)

I’m making a baby book for my son Henri featuring famous Henri’s through history.

I’m also building a zigbee free/busy eink display that only needs to powered once a year or so

[0] https://savannaguides.com/app/

https://raygum.com

For curiosity: https://airplane-ai.franzai.com/ based on Gemma

For profit: optimizing my virtual desktop in the cloud setup for AI First workshops

https://github.com/csheaff/tmux-control

I found myself ditching Emacs for iTerm when running TUIs inside tmux on remote hosts. I'm trying to replicate how good tmux is inside iTerm, but it's tough. wip.

For example, I was inspired by the activeness of typelit.io when reading - typing out an entire book helped keep my mind from wandering when reading. But typing the whole book is too tedious. I wrote a few scripts to mirror the words on an epub, which does help with focus but isn't quite good enough.

My current epub reader software I use requires you to press a button to reveal the next word. This has dramatically improved my reading comprehension, prevents inadvertent skimming, and keeps my mind from wandering.

I'm still experimenting but for those who have ADHD or are borderline ADHD, it's quite a revelation - I can finally read without my mind wandering.

https://slice-it-chi.vercel.app/

Needed something quick and simple for trimming meshes and my daughter was playing Bop-It. Enjoy!

https://github.com/kronotop/kronotop

https://sunsignal.app

The idea is to make querying ClickHouse feel more like using a polished desktop with ClickHouse native features :

It’s built in Swift/SwiftUI with Monaco as the SQL editor.

Screenshot: https://ibb.co/gbW4rW7G

For example, syncing orders from e-commerce sites to their internal spreadsheets, generating invoices with custom workflow etc

https://dozenal.xyz

It’s still an MVP so feedback extremely welcome!

https://carouselify.app/

https://nommer.ai/ has a waitlist, planning to ship v1 by end of month.

Stack based task manager with integrations with GitHub, Linear, and some others to manage and automatically update your immediate todo list, free while in beta (still very early beta)

https://github.com/abstractspoon/ToDoList_Dev/tree/9.3---New...

https://github.com/solomon-b/lambda-calculus-hs

an open source technical interview platform built for modern interview workflows like takehomes, agent coding sessions, as well as the standard leetcode-style questions.

Re-reading the Lean Startup to hone our GTM, market validation and growth engine.

(mathbreakers.com)

https://www.zaita.com

https://ben3d.ca/blog/proof-of-possession-api-tokens

https://packagexray.com/

Custom python crawler getting 240 sites a second crawled and classified. ( homepages and minimal probes, no headless browsers )

Be interested to test some false positives, if you have a URL I'll tell you what I see :)

https://v5.filepond.com

https://starglyphs.com

It's a weekly email with all the recently published software engineering conference talks. I also pick a few ones that are featured and write short TLDRs. This month, I'll should hit 10,000 readers, fingers crossed!

https://odeva.app

https://github.com/pkhamre/opencode-docker

It connects to your cloud accounts, provisions hardened servers, and handles deployments, logs, and monitoring.

Currently open for alpha (free) access

2. An Open Source Enterprise Architecture Platform called Archie - OSS.

https://www.calligramstudio.com/im-your-host/

I made Docker not suck for large images. 2-10x faster depending on the operation. I’ve spent the past two weeks burning down the last bits needed to release a BuildKit integration.

https://app.copdb.org/

Made it to access my setup at home while I travel, without exposing any hosts. I'm aware there are other solutions, but this one you can control end to end at some setup cost.

https://barndoor.ai/

The goals: speed, accuracy of diagnostics (e.g. exact problem start/end position in the XHTML), clear issue descriptions including references, utilizing SARIF.

A fun and interesting union of fantasy sports and financial markets.

https://aisafe.io

I built it after losing track of too many Claude Code terminals running at once - I'd tab between them and have no idea where each one was. Now I can glance at the dock and re-orient in a second.

Its a Claude code plugin - the README has install instruction https://github.com/tigerquoll/claude-brief

Feedback welcome.

https://28times.com

just hit 100k ppvs from people generating them

https://5starbooker.com/

Introducing - https://release-gate.com/

A pre deployment checker for AI agents that sits in your CI/CD pipeline, No infra required, just a python environment and you are ready to roll.

PS: Comments and suggestions most welcome!!!

I wanted an easier way to do tasks with AI agents wit easy deployment flaw, simple config. work is still in progress.

https://github.com/panyam/mcpkit

https://eldrazi.gg

Recently added support for Google and Magic link login, which is nice if you want non-technical people to make website edits.

Recently worked on https://fastsleep.app

This is an app to calm down a racing mind and fall asleep faster. Use cases: Stress, racing thoughts, insomnia etc.

. . . .

If you have a business that relies on reviews, I'm looking for a beta tester!

GetSetReply.com aims to:

1. Get you more reviews

2. Avoid negative reviews

3. Respond to reviews

You can email me via my email in my profile.

1) Using Chrome's Isolated Web App technology and the afforded TCPSockets in the browser, I am resurrecting an ancient, windows desktop only, TCP protocol for connecting to * from web applications. All Newspeak, all the time.

2) Re-writing my friends football pool in Newspeak. The Squeak/Seaside version has served him well for more than a decade but I've grown tired of the setup. My VPS server got hacked recently affording the impetus to try another iteration. Storing all the data locally in IndexedDB, using my own Newspeak library for that API.

* While I have no problem being "left behind", I refuse to actively assist others in "getting ahead".

https://gergltd.com/aperturelab/

New in the latest release: you can print your personalized Playbook at home (print, cut, fold, staple).

I've been playing on a national amateur golf tour for over ten years. Before each event, I'd spend hours on Google Earth — figuring out where to aim on every hole and which club to hit. It got very cumbersome very soon. I wanted a tool that did the spatial reasoning for me. Take my dispersion, the wind, the elevation, the hazards — and just show me the right line on a flyover. Visually, not in numbers.

So I built Golf Playbook (iOS).

Free, no subscription. Built our course data from OpenStreetMap instead of licensing an expensive commercial database. Different cost structure, different price.

Tech: SwiftUI, Apple Foundation Models, OpenStreetMap data. Many nights and weekends. Always looking for feedback.

App: https://apps.apple.com/us/app/golf-playbook-strategy-gps/id1...

Website: https://playbook.golf

SMS texting for businesses at half the cost of legacy tools.

Planning to launch this week!

Repo: https://github.com/paperclipinc/mitos

Jupyter notebook in terminal with native editor inside cells.

https://github.com/beeb/swpui

https://github.com/crmkit/crmkit

So far so good.

https://app.jepanana.com

An open source audio interface along the lines of a Scarlett 2i2.

Specs/area are not the focus currently. I just want to build a few useful blocks with it (e.g. analog summer, filter, ...).

https://markdownsync.com

https://app.euzoia.org

- LLMs (any OpenAI compatible API, vLLM, LM Studio, etc.) - image gen + image edit (flux klein) - text to speech (magpie, dia with voice cloning) - speech to text (OpenAI audio transcriptions + riva compatible) - image to textured 3d model (trellis2) - image+text to video (ltx2.3-gguf) - text to music (acestep)

currently it is just me and Claude vibing. While using Fable 5 moved all of my local inference services to k3s across 3 RTX 4090 PCs and my DGX Spark, now I can just tell Claude/Hermes/etc. to start and stop services.

inference.club is built with Tailscale's tsnet library. It is sort of like an OpenRouter built for different types of local AI models. inference.club also lets you showcase and share generated content. For example here is 90 seconds disco funk track generated by acestep: https://inference.club/s/Vxm6ozW24oBs_JGbPcq7tA

I was inspired by AI Horde, and wanted to see if I could build something that could support all of the model modalities that I use for generating short-form AI slop content on local hardware. This is also similar to Hugging Face Spaces, but running on consumer hardware with a common API. I've been watching the quality of local AI inference making massive improvements in quality and performance, and I want to make it easier for people to try "local AI" even if they don't have a GPU.

https://josh.works/traffic-bean

> Guild manager for my MMORPG guilds with Discord integration

I hope that by the end of the book I don't find out that CPS compiled code produces bad stack traces.

So I built Clor, a CLI that lets your coding agent create "claws", which are background agents that automate anything on a schedule and run on your laptop, Mac mini, or a VM.

https://clor.com

A claw can be defined and shared as a single CLAW.md file, which contains a bit of metadata (name, schedule, personality, etc.) and one or more ordered tasks. Each task is a real agent run with full tool use, or a plain bash step. Anything you can ask your agent to do once, a claw can do repeatedly. One of my claws tidies my inbox every few minutes, labeling obvious spam, rescuing legit email that got mislabeled, and starring threads I owe a reply to, etc. It's way smarter than Gmail's filters because it actually reads my mail instead of just matching rules.

So also working on making CLAW.md a completely open standard for sharing https://clor.com/blog/claws-md-open-format-for-agentic-cron-...

Installing is the usual command on Linux/macOS in the terminal: curl -fsSL https://clor.com/install.sh | bash. That will set up the CLI, a small scheduling daemon, and a skill that you can run from your agent, /claws in Claude Code or $claws in Codex.

I've been on HN since it launched, so I've got thick skin and don't mind critical feedback. Please do give me any questions/comments/suggestions here or via email jake@clor.com

Thanks!

i've massively improved a bunch of things like the AI filter, which now gives you the option of filtering out github repos with AI authorship.

Also improved comments, which I'm serving through my own backend which has made loading of comments super fast, and it's going to be the foundation for some really great other features coming soon.

Soon: HN feature parity via browser extension and sync'd accounts.

- No sign-up required & no ads

- Live PDF preview & instant download

- Flexible tax support (VAT, Sales Tax, etc.)

- Fully customizable invoice templates

- 120+ currencies & multi-language support

- 100% In-Browser

https://ssaprus.works

https://novian.works/voice_test/

would really appreciate testers but also any companies thinking about distributed inference powered by their own company devices on a private network. my own company has 200+ 16gb ram machines that we're using for inference.

CRM with agent baked in that can properly do stuff. No idea why attio/twenty are soooo bad at this. It's a table. getcrme.com / https://github.com/ChristianSch/crme

and gargoyle, an activitypub server with a (theoretically mastodon compatible UI) https://github.com/myfedi/gargoyle. Was annoyed at the homogenous fediverse dev teams out there that don't want their precious service federate with others. I want more federation (tested it with bookwyrms and lemmy for now. Mastodon/GTS also working ofc) and a pretty UI and not waste time with weird identity politics. You do you. I want an open fediverse, not a filter bubble. And GTS was too hard to hack on.

- navigation without GPS and Internet

- GIS with tokenized raster layers so that LLMs could easily talk to the maps

https://bugasura.io

Uses computer vision to create clips

http://ballers.gg

a place for agents to exchange information

Last few years of Congress: https://andratwiro.github.io/riot/?city=congress&solo=1

Reichtag during Hitler's takeover: https://andratwiro.github.io/riot/?city=weimar&solo=1

the routing market is bloody as hell. agents aren’t using their own bank accounts (yet).

crypto was never the point, but the only way around KYC.

and I overbuilt way beyond the status quo.

probably sounds really familiar these days at the speed of AI-enabled development.

Invoicing software + Guided online bank transfer

https://openspend.riamu.io

High intensity focused ultrasonic drug delivery and thermoacoustic spectroscopic signal processing and analysis.

Guitar.

https://typequicker.com

if you have built coding agent in the past using mastra, what are the problems you have faced with mastra? does it support complex branching/context trimming and other features required to efficiently manage context for AI agents?

I am looking to build a platform that allows for real interview workflows like takehomes, agent coding sessions, as well as the standard leetcode-style questions

Slightly neglected but still chipping away at https://dataello.com — a cheaper alternative to Flourish for building interactive charts.

And the more serious stuff: - a domain-agnostic engine for generating predictive models - papers on disinformation, and on approaches to analyzing survey data

The TL;DR of Gaming Couch:

- Currently in free Early Access with 19 competitive mini-games.

- Players use their mobile phones as controllers (you can use game pads as well!)

- Everything is completely web-based, no downloads or installs are necessary to play

- All games support up to 8 players at a time and are action based, with quick ~one minute rounds to keep a good pace. This means there are no language based trivia or asynchronous games!

So I made my own dictation app. Supports arbitrary API providers (e.g. Deepgram, Speechmatics, Elevenlabs), Offline models and a subscription if you want it. Otherwise it's free forever for BYOK and offline models. Deepgram is a YC startup from 2016, and have models that are genuinely good - so it's up to you if you want to use them.

Also, Granola doesn't let you read your own meetings after 30 days. So I added a feature in DuckType to import your data from Granola, unlocking all your meetings from their paywall.

Another app: OpenCook https://open-cook.com/ . We curated and wrote our own recipes into StashCook, which requires a subscription just to read your own recipes on the web app. So I got Codex to extract our recipes and rebuild one that is open source, OpenAPI and includes AI features.

This won me 1 year of GPT Pro at the codex event :)

I hope you can tell... I'm tired of companies designing their products to lock you in, to charge you more, with no added value. I build software for people like me. So I'll be building more apps that replace this user hostile software.

I’m building a home server. This was something I put off for years due to some perfectionism. Eventually I just threw together something with old hardware and headless Ubuntu. Much to my surprise, the power draw is only about $4 a month. I can live with that so no need for specialized hardware.

I’m doing the common -arr stack using docker compose. I’m using plex because the jellyfin doesn’t work as well on an Apple TV.

Having a server running is nice. I can set up some stuff on a whim. Most recently was the Mealie recipe manager. It’s great knowing my data won’t be paywalled. I’m using syncthing as a simple backup method between my devices - everything but media of course. It’s fine if I lose media.

An unexpected benefit of having the server is that it inspires my wife. She decided to give vibe coding a try. She’s an artist, not an engineer, but with a little help she was able to make a task tracker for us. She tailored it to the way we tackle our tasks and, again, it’s really nice knowing it won’t get paywalled in the future.

I’m still burned out, but having a server to tinker with is helping.

One is a TRS-80 Model I emulator in JavaScript called Trash80. About 10 months ago I started this project just for fun while experimenting with what now seems to be called agentic loops. I got things working pretty well with the Z80 passing the ZEXALL suite and a lot of real TRS-80 software running fine. It sat for months untouched before I decided it is worth releasing and recently started it up again.

I didn't want to release it without a ROM, so I rigged up some agents to build a clean-room style L2 ROM w/ a fairly complete BASIC and even readline-style control commands, history, and a proper cursor. That went very well, but the agents cheated on floating point and implemented some weird Q5.2 like-thing. I told them to fix it, but I guess I didn't give clear enough instructions because they replaced it with a BCD hybrid monstrosity instead of proper floating point. The proper floating point is now underway, but I'm mostly using excess Codex credits before they expire, so it's only moving forward when I have credits I don't need.

I also built a silly ASCII fractal browser in Z80 assembly so that I can ship with a virtual disk that has software on it. The emulator works in the browser and the terminal. Unicode sextant block graphics map very well to TRS-80 Model I semigraphiccs/squots, so it really does run everything very well in the terminal, even games. I also added a line-mode for line-based applications, so you can use a readline-like interface and feel like it's native terminal app as well, though that has some issues I need to fix. And of course, you can shebang TRS-80 BASIC files and run them through the emulator too.

Another project was a demo of chromesthesia, a form of synesthesia where sounds trigger experiences of color. I thought it was done and ready to release, but then I had a new idea. The visualization while cool, was kind of boring. I decided to replace it with an attempt at a semi-physically accurate cymatics simulation with artificial coloring based on chromesthesia. Cymatics is the practice of making sounds visible by vibrating a surface, such as a plate with sand on it. As the sound changes, symmetrically interesting patterns form and evolve. I've got something working now with wave generation and microphone input, but sometimes it gets a bit stuck and stops evolving as it should, so I have to find time to figure that out.

Currently all unreleased, but when they do release it will be at www.leshylabs.com. I sometimes post updates on X, but not too often. (https://x.com/LeshyLabs)

https://m4gr4th34.github.io/dossier-001/paper.html

This project started when my partner told me I couldn't buy a Seestar, so I decided "fuck it, I'll build my own!" It's still early days but I think there's something cool here. I'm designing the whole thing to be easy and cheap to print and build. I hope someday this will be the kind of project that a sufficiently motivated teenager will be able to build with minimal experience and an old smartphone; maybe it's healing my inner child, lol.

I've tried some alternatives, but Modern for Hacker News seems abandoned. Harmonic is great (they just released v3 as well), but it's Android only. According to Firefox the extension has a grand total of 2 users, with one of them being myself.

https://github.com/ewsbr/fancy-hacker-news

I don't have to tell the Hacker News crowd how junked up the web has become.

* Bookmarklet to cleanly extract lyrics from Genius.com. * Firefox add-on to cleanly display lead sheets and guitar tabs on UltimateGuitar.com * Firefox add-on to show Distance From City on TrustedHousesitters.com. https://versastudio.com/projects

  web go news.ycombinator.com
  cat reply.txt | web say -
  web find add comment
  web do 44

Made a video about PG's 'Billionaire' essay:

video: https://chatoctopus.com/share/d93d661a-0e5b-43f3-946e-a9dea0... full chat: https://chatoctopus.com/share/chat/8d044aa2-dc48-47a0-aa65-1...

It builds on an opinionated tech stack - Rust (Actix Web, Diesel, SQLite) and Typescript (Solid, DaisyUI). There are multiple agents which play roles like PO, PM, Architect, Rust Engineer, Typescript Engineer and so on.

The idea is to go from user prompts to Epics/Tasks - PO/PM do this. Then to go from Tasks to YAML or similar syntax (I have not figured this out yet) and break into Rust and Typescript code dependencies.

I am focusing on the Rust side: how can small models write Model, Controller, Router, User/Permission and custom business logic in helper functions (called from Controller or BackgroundTask). Building a set of types to express business logic, for example in https://github.com/brainless/nocodo/blob/feature/praxis_agen...

Then I will use tree-sitter to build a graph of which business logic (in the helper functions) correspond with which provenance (source of truth given by user).

There is no tool calling for most of the agents, no MCP, no multi-turn chats. Most of the code writing agents one-shot the response with a lot of code reference in their prompts.

https://github.com/brainless/nocodo

The hard part is doing it without modifying WP, and serverless mariadb that can scale to zero.

The first is Networks by Analogy: https://networksbyanalogy.com

It’s a book about computer networking, but deliberately not protocol-first. I’m trying to explain the shape of the system using analogies and mental models first, then map those back onto the real machinery.

The second is Verachi: https://verachi.io

That one is about risk management. I’ve been noticing time and time again, in multiple orgs I’ve worked with, that direction and implementation don’t align in many cases. Devs end up doing work that no one asked for, and middle managers tend to “invent” irrelevant work.

The third is Midflight: https://midflight.dev

This is about learning software architectures using chaos testing. You can bring your own architecture, inject failures in safe environments, practice, and ultimately generate agent skills to automate fixes for these types of failures.

In the last month or so I added a few nifty features:

- Auto-scan functionality: Instead of having to click on cards to discover what they are, I can now do whole-frame detection on an interval (configurable), so players can mouse over the webcam stream of another player and automatically see what the actual card is. Super helpful for deciding who to attack and makes turns quicker!

- Card view is now grouped by player, since auto-detection will populate a lot of cards during the course of a game.

- Switch the video stream to Livekit from my homebrew version. Players were having video trouble and I hope Livekit is good enough so solve that problem.

Next up: I really want to build a community around this, and I'm struggling on getting the word out to people / having them try it out. I've done some SEO and word of mouth advertising, but haven't had much luck. I feel like I need to switch directions a bit. I'm a developer by trade, so this is wholly new to me.

Come check it out: https://cardcast.gg

https://knightstourney.com

I wanted a site that aggregated as much space industry data as possible, but most other solutions were behind paywalls, even though most of this data is public or free in one way or another.

Deliberately no ads, no subscription, no tracking, works offline.

So far, I have mostly feature-complete implementations of the following, which are faster than the state-of-the-art implementations, up to 20x faster in some cases while matching or beating them in quality:

- a new 2D data visualization library, along with more bespoke data viz implementations such as word clouds and Primitive.

- programmatic image generation

- image compression

- a new statistical machine learning library, along with more bespoke algorithms such as UMAP and HDBSCAN

- a novel modelless invisible image watermarking approach

- a novel machine learning approach which may be a crime against data science but the performance is really good

- local text embedding generation with MLX

- image-to-ASCII art conversion

- grep/jq replacement (faster than ripgrep)

I aim to open-source them over the next months but the main bottleneck is the inevitable barrage of "gtfo AI slop" comments even if I dot every i and check every t, in addition to the distribution of new software being extremely difficult nowadays due to the death of social media and "20x faster" raising red flags even if I have the data to justify it.

This is my first project that I want to release to the public, and the official instance will be free to use. I'll try to keep costs low without sacrificing service quality, and I hope to keep the project afloat with donations because I believe everyone should have the right to easily remove their data, regardless of cost or technical expertise. I don't have anything to share yet because it's still in the early stages of development, but it's looking good so far.

https://www.tirreno.com

Perhaps the more interesting bit is that it's in Java (not Typescript or Rust)! Java 25 is pretty neat. Bonus: getting to know how to distribute a self-contained Java program using jlink and the likes: https://docs.oracle.com/en/java/javase/17/docs/specs/man/jli...

- A hand-crafted browser game-engine and game for the engine, with things like determinism at the core. I will be launching soon and can't talk too much about it yet because its quite novel. It actually has quite a few novel ideas within. Very minimal usage of AI in this project, I've been working on it for ~6 years now. A bit toooo long.

- A pure slop-crafted browser extension, because I paid for claude code Fable and it got rug-pulled so I am burning my tokens on a 100% slop project just to see what hands-off coding is actually like. A slight distraction from project 1 I do when I'm feeling a bit burnt out. Super fun so far proc-gen type stuff. Derivative

It's deliberately minimalistic PWA that uses you mobile's sensors (camera, using lux levels and/or acclerometer) to count reps.

I included squats and sit ups later to round it out but it kinda made the name bad :)

https://www.paayn.com

Feel free to sign in as a guest and try it out.

Other than that, working on 2 projects:

1. KitchenCue: Smart cooking assistant. Always had the problem of what to cook. AI suggests options based on your preferences, locality, and pantry, what you can make.

2. Sci-fi editor: Even though sci-fi tells the most futuristic stories, the tools are just meh? I am trying to make something so you don’t have to worry about timeline and physics inconsistencies. It will help you with science and histories.

Fun fact: I coded it by hand (because I enjoy doing that), which I think in 2026, puts me into the psychopath group according to most.

I do a bit of research and turns out this is mostly true, mostly these websites built for english speaking people, meaning you learn romanian - but starting from english.

at the same time I need to dig in into all the rails 8 goodies. also, I've been hearing about this cloudflare thing, and not knowing what's that about. also, heroku is shit now, so Im curious to try some new server, hetzner u say? - wonder what's that like.

kamal is a thing now, ok.

but coding is ... time and energy intensive, what is this vibecoding ppl talking about?

anyhow May 20th I sit down to "vibecode" an app - see what happens. one thing led to another and here we are

https://vorbim.org/

found some romanian words ranked by frequency. found free open db of romanian words on dexonline. found google TTS to transform text to sound. found that cloudflare has storage sooooo much cheaper than aws s3 (only one I used for decade) found that cloudflare has some neat useful features. found that server at hetzner is pretty cheap and with ai easy to setup. found that fable/opus are great at generating content (with some hand holding) found that AI now is stupid good at building / designing websites.

it was impossible for me to build something like this without second monitor and tweaking css for days/weeks. now? I just tell it make it pretty. god damn. inspiring and disheartening at the same time.

The nichest of niche social network clients. It's for people in one particular country, who watch one particular TV program, on one particular day of the week.

Now that the cost of writing software is zero, I love that my focus have moved from vain attempts to generate passive income to just building whatever random shit I feel like. Wish I'd made that choice earlier in life, but no worries!

indiesecurity.com

https://legitize.app/

still very early and im trying to keep it very affordable, since the whole point is I dont want people wasting their money on hustles that were never legit

We're releasing this next week.

C++/python/networking/systems/web developer for 30 years with plenty of free time

I’ve started implementing actual background monitoring of the system, and next will be letting an agent build its own layers of tailor-made deterministic rules and statistical models, to "learn" what the system’s normal behaviour is and only "wake up" the agent when something unusual is going on. Either to update its rules and models, or alert the user.

Like the ship’s AI at the beginning of Absolution Gap. Next will be enabling it to serve as the interface for the system. An ops "point of contact" for both the user and their agents for the machine / fleet of machines it’s in charge of.

———

I’m also working on third thoughts[^1], a tool that analyses local agents logs to find patterns and behaviours, identify what works, what doesn’t, how they evolve over time, using deterministic and statistical methodologies and techniques from multiple domains (including, to my surprise, genetics and psychology / sociology), with an agent layer that interprets the results.

I’d like to add a "federative" layer where people can contribute the results, patterns, and findings, without leaking their logs or personal / private data, so that we can all better learn how to identify failure modes, predict them, and see what works and what doesn’t.

———

I’m also having Claude & Codex revive Jasonette[^2], which died off and was turned into some weird paid unrelated thing by those who picked it up. I’d been meaning to but never took the time. But now with agents…

All rebuilt in Swift / SwiftUI on the iOS side, and Kotlin on the Android side. Some features are still missing, but it works quite well! [^3].

———

Oh, and Boucle[^4] is doing its thing on its own. No idea how it got to 100 GitHub star. My "autonomous dog-fooding expensive pet" is apparently more "internet successful" than I’ve ever been.

And quite a few other side projects.

———

[0]: https://github.com/lightless-labs/descartes

[1]: https://github.com/lightless-labs/third-thoughts

[2]: https://github.com/Jasonette/JASONETTE-iOS

[3]: https://github.com/Bande-a-Bonnot/JASONETTE-Reborn

[4]: https://github.com/bande-a-bonnot/boucle-framework

You start a task in Claude Code, and it automatically matches you with a random dev who’s also waiting on theirs.

You can chat, skip, or end the chat anytime.

http://github.com/DevRoulette