It's been really fun to build with. Agents can create parametric procedures so e.g. stick framing becomes a simple function call for the next agent, building a flywheel. There is full agent-human parity in every surface, so there is a human UI for the procedures too.

Every operation is yaml, so agents pick it up pretty quickly. Agents can also file feature requests when they reach for a tool that doesn't exist. You can export to 3d printing files, video walk-through, step files, get a BOM and a cut plan, view your project in life-size with AR. There is a notion-like interface for authoring build guides... a lot going on. If you're a woodworker/software engineer you might enjoy it.

You can add the MCP to your agent of choice, send a picture, description, sketch or whatever; say "build this with Sawdust"

https://sawdust.diy

https://celerp.com

https://www.idlequest.net/ - a from-scratch recreation of the 1999 MMORPG classic EverQuest, featuring a real-time MMO server written in Go, a 3D game browser-based client built with Babylon.js, and the clasic UI recreated using React. You can play it both as a regular MMORPG but also in "idle mode" where it basically plays itself. This had up to 70 players online at once a while back which was really cool, though its popularity is in a bit of a lull right now. There are still tons of bugs and stuff that isn't fully implemented (and balance issues) but it's still fun for most people who have nostalgia for it.

https://www.newyokosuka.com/ - an unofficial Shenmue MMO experience. Based on the 1999 Sega Dreamcast game Shenmue, it's playable entirely in your browser! It's basic world exploration with forklift shenanigans, some basic dialogue systems, and a basic combat system test, but I'm about to push an update that includes all cutscenes and story progression as well. The story part is taking a bit of time because I'm having to mold it to fit in an MMO context. But it's a fun project to work on and the Shenmue community loves it so far.

https://proofleague.com (iOS, web app and android)

You create a private league, set a weekly goal (workout 3x a week), and tap Start when you begin a workout. Friends get notified and then have 30 minutes to ask for a selfie. If nobody asks, the workout counts automatically. There’s no public feed or strangers involved, just a small group keeping each other honest.

My friends and I had been doing a version of this via text message for years, but this app has been great. I am in 4 "leagues", all of them get notified at once and then I only share my selfie once and it automatically goes to any group that asks. It's motivating and hilarious to see people working out.

It's free and would love for you guys to try it and set up a league with friends or family. Please send me any feedback at amit@proofleague.com

Try it out: https://github.com/preloopdev/preloop

So, I built a tool to answer that. Major goals have been to keep low energy/cpu usage (so I can run it 24/7), have it adapt to the apps/traffic I'm using (rather than use static monitoring endpoints), and to deliver both at-a-glance answers in the menubar and in-depth detail in the dropdown.

It's called Breakdown. It's a free (for typical uses). It's Mac-only for now (but if enough people ask for Windows I'll port it).

https://breakdown.live

- it is a collection of ~ 2700 temples across India, with images sourced from wikipedia

- it shows you a random temple each time you visit

- it has a map view of temples across India

So this is just the tip of the iceberg. I am trying to build a catalogue of all temples, starting with India, and expanding on to the rest of the world. The focus is on temples originating from Indic religions like Hinduism, Jainism and Buddhism.

I have personally discovered many cool temples that I have never heard of, but I am struggling on how to gamify this. Feedback welcome!

It captures the screen recording along with console logs, network requests, and session activity so you can get to the root cause faster

https://github.com/0xnyn/userplane

https://pi.basilisk-aeolian.ts.net

Previous agents developed:

Katto https://www.npmjs.com/package/@kuyawa/katto

Mecha https://www.npmjs.com/package/mecha-ai

I used to be a mechanic, and spend a lot of my free time working on project vehicles, motorcycles, tractors, trucks etc. I wanted a tool to track the tasks I needed done, then a way to easily access VIN info for parts search, then I DMV records, and finally built an iphone app to scan the OBD2 diagnostic codes and hook them up to a custom ai diagnostic prompt.

It's been a blast to work on, I need to focus on marketing it and get some users that aren't close friends, but it's been serving my purposes this summer so far.

I've seen nothing with anywhere close to this depth of diagnostic reporting.

https://crewchief.cc https://apps.apple.com/us/app/crewchief-auto/id6760673109

- the desktop client: https://github.com/mickael-kerjean/fdrive

- the web client: https://github.com/mickael-kerjean/filestash

It started getting some search impressions and clicks, so I decided to launch the next 9 of the top 10 ideas that ChatGPT came up with for this type of site - won't post all of them here, but https://the-dwell.com/ (data on ship and truck dwell times/port congestion) is doing the best thus far from a traffic perspective.

First I had it send me a weekly analysis of the GA4/GSC data to see what could be improved about the site, but I've since automated that - each week it reviews traffic and search queries, then updates articles or creates new ones to meet demand. So now in theory I have a full engine to launch these sites and have them self-improve over time. Kinda neat to see all of that being done autonomously.

The thing that these sites really need are some backlinks, so I'm thinking through how to get those. I had ChatGPT generate some lists of places that might find real value in linking to these sorts of things, but I'm unwilling to let an AI agent start emailing people. I'm going to try sending some emails to some of the places that seem like a really good fit, see what the response is, and if it's good try to figure out how to do that on a larger scale without AI email spam.

I started the original project as an excuse to learn SwiftUI, then been using it as an excuse to test all the frontier models and etc. to see how much better we’re getting at AI-coding. Kinda fun to see a couple dozen weekly users semi-competing with each other. Obviously nothing big, but the feeling you get seeing someone else use your app is very nice.

I was never much of a game developer, but recently my 5 year old son wanted to play a game so we decided to build one together.

It's a boat game, you basically steer a boat in an isometric 2d world, transporting passengers, cargo etc between ports.

As we designed it, the ideas just kept on coming. He made or directed a lot of the art inside of the game (even the audio), and we included friends and family as characters within the game.

A lot of fun to build - hilarious at times. I used Lua and LÖVE2D, building basically a game engine for an isometric world, so that took significantly more time than expected.

If you want to test it [1], please do, but keep in mind it's only in Norwegian, but I am sure most people would be able to figure it out as it's meant for age group 5 and up:

[1] https://apps.apple.com/no/app/b%C3%A5tspillet/id6791630382

At this point our entire extended family and their kids, grandchildren etc are actually playing this, so it's been super fun.

https://store.steampowered.com/app/4564800/Dictatorship_Simu...

https://github.com/Ymirke/tmux-agent-switcher

You press ctrl+n and you get a sidebar showing all the tmux tabs you currently have and the statuses of the agents.

The sidebar then has a couple different navigation modes based on what floats your boat, toggle by tab:

1. Using vim bindings j/k, and supporting number -> j/k to go up or down quickly.

2. Using number -> number. Meaning you press the number of session then number of tab.

3. Using search, useful if you have a ton of sessions open.

I really like what herdr, cmux and others are doing in this space, but I find it hard to get myself away from my core tmux setup, so I made this to not have to change too much of how I work.

It's an automation game and factory builder with "falling sand" physics. Think Noita meets Factorio.

So, I'm building a compatibility layer; something that works with everything - including your own vibe-coded personal CRM.

It's already helping - even something as simple as correlating calendar events with new connections so that you always know where you met someone.

https://tend2thrive.com if you're curious; It's live, so DM me if you'd like an account rather than just hitting the waitlist.

Which leads me to trying to get the processing off github actions (it's all duckdb pipelines), which has led me to improve the orchestration implementation of my 'better sql' [2] to optimize the asset based refresh flow. I'm now wiring that up in a general cloud service to give me the data orchestration platform I've always wanted. Building a multi-tenant cloud experience has been interesting!

[1]: https://greenmtnboy.github.io/sf_tree_reporting [2]: https://github.com/trilogy-data/pytrilogy

I really enjoy working on the app though. The backend is Elixir, with a Phoenix LiveView dashboard. I've got a cluster of 3 nodes running, talking to each other. The probes that check the monitoring targets are tiny go binaries, spread across hosting providers across the world. I've also got synthetic probes now, running in little playwright sandboxes.

A lot of the challenges have been around how to distribute work across the probes, with different strategies for the basic TCP/HTTP probes vs the synthetic workers, and how to effectively store large amounts of events (Clickhouse).

Most tools just focus on frontend tech like Shopify or Wordpress. Bloomberry shows you who uses backend tools like Hubspot, or Workday, or Gitlab for example.

Example: https://bloomberry.com/data/github-enterprise - companies that use Github

I've also been slowly chipping away at a Jagged Alliance 2-like game in Godot. Nothing to share yet but if anyone else is also frustrated that there hasn't been a good video game since Jagged Alliance 2 and you want to work on it reach out to me through the contact in my profile.

A programming language that makes your game multiplayer automatically! It integrates rollback netcode into the programming language itself, guaranteeing that whatever you code is deterministic and can be snapshotted and rolled back. Then it integrates the networking and server automatically so you can just code your game like a singleplayer game and it'll be multiplayer automatically! I've been working on this for four years now.

https://github.com/paradise-runner/toast

It has all the parts I want (lsps, syntax highlighting, a file tree) without the parts I don’t (a bundled terminal, tracking, ai)

1) grounding LLM scripture references in the actual text and eliminating hallucinations. This is the platform for that. https://withlattice.com

2) how to use AI to get people into scripture more as opposed to being a substitute for it. This is the product I made for it - it uses #1 above. https://trysojourn.app

I've worked on it for about a year, with 1700 commits. I've been going back and forth if I should just open up the canvas or also the multiplayer experience.

I've always had the dream to make some money from a side project, but I don't think this one is it, so I'll just make the entire repo public. Just want to clean up some stuff first.

Lots of fun tech used: duckDB WASM, Cloudflare Durable Objects, tldraw and pocketbase

For now, there's no backend and it's hosted on GitHub Pages; it's a static website reading chunks from an sqlite-based DB file. I intend to change it in the future by running an LLM (preferably a frontier Gemini model, as works great for Persian) over the whole data set so you won't need a key to read the translated poetry. However, I don't have the budget of $1000-$2000 to spend on the tokens currently.

Website: https://0x5ce.github.io/farsidaan

Code: https://github.com/0x5CE/farsidaan

P.S. Contributions welcome.

https://spicycircuits.dev/

I just finished my master's in Psychedelics and Consciousness Studies, and built the library I wanted while studying. I started it over a year ago, but put it down until my practicum advisor suggested I dust it off and go hard on it during my last term.

As of this writing, there are over 35,700 papers by over 82,200 authors organized into 37 topics, growing daily. There's a 2D map of the whole corpus and evidence syntheses on the topic pages, plus the ability to generate your own syntheses with any prompt.

It's built with Rails 8.1, uses one Postgres (for full-text search, vectors, and job queue), and runs on a $24/mo DigitalOcean droplet that I just upgraded from the $12 tier and deploy to with Kamal. Total LLM spend so far is ~$28 in DeepSeek-V4-Flash, trending down after a big one-time backfill push.

Relevance was the hardest part to get right by far. Ensuring we keep papers on LSD the psychedelic vs Lumpy Skin Disease, or Ketamine for depression vs anesthesia in cats was no small feat. The design ended up being a cheap keyword prefilter, then an LLM rubric that accepts or rejects papers. More on that here: https://consciousnesslibrary.org/docs/article-pipeline.html

It's free, no ads, no signup to read anything, and a registered 501(c)(3) I fund myself for now. I'd really like to know what breaks or any other feedback, and would love to answer any questions about it!

As a small way of standing up to them I created https://rigove.co.uk/ (rightmove without htm - the hidden toll machine ;)

If you change rightmove to rigove while browsing a property for sale you get a page which shows where else that property is listed.

It is only a few days old so it is currently more miss than hit but I plan to reach out to estate agents to increase coverage as quick as I can.

https://meltdown.merkoba.com

This is an AI Harness + Platform, made in Python and Tkinter.

It has a lot of advanced features, arguments, commands, shortcuts.

Lots of widgets and the markdown parser were done from scratch.

It has a powerful API to create conversational sessions interactively.

You can learn about it on a blog post I made:

https://github.com/madprops/blog/blob/main/docs/meltdown/mel...

wireplug lets you create mesh VPNs using standard WireGuard. Your wg config files stay almost the same, except you no longer have to specify an `Endpoint` for your peers. Instead, wireplug detects all your possible endpoints (including LAN) and coordinates them with your peers for you. It handles NAT traversal and works with the in-kernel WireGuard driver on Linux and OpenBSD. This lets you keep managing your own keys and network topology, while also maintaining connectivity when moving between networks.

Currently working on improving NAT traversal by adding support for PCP and NAT-PMP.

https://github.com/mrieck/demoday-claude-plugin - create demo videos for your projects using Claude

https://github.com/mrieck/overboard-plugin - CTO assistant, PM helper Claude plugin

https://plugmyplugin.com - Weekly voting contest and directory for Claude Plugins similar to Devhunt/ProductHunt

Tell it your 5 favorite albums, get an immediate suggestions list. No sign up, free to use, integrated with Spotify to hear immediate samples (or the whole album).

https://SimilaritiesEngine.com

I’ve mentioned it before, but we can get some pretty good results for developing implementation and tests with this setup. The context isolation makes it easy to separate test and code writing using a specification as a source of truth. Tests are then run by an arbiter that feedback to tests or implementation depending on who it blames for test failures. The tests are then treated as an independent implementation, and through the math of coincident errors, the arbiter feedback loop ensures that both are eventually correct (N-versions and clean room research did this with humans in the 80s). This then allows us to use less reliable LLMs to develop code, like Qwen on a MacBook Pro.

I hope to have something out on GitHub before my beach period ends (well, if I’m unsuccessful in getting a new role, then I’ll have a lot more time to play at least).

https://github.com/smol-machines/smolvm

[0] https://trebel.la/

I dare say it’s one of the most polished PWAs in existence, especially on iOS. Nevertheless, I’m experimenting with a Capacitor build, because most customers and visitors use the app on iPhone, but few are aware of Safari’s “Add to Home Screen” feature, so they miss out on the optimal UX. Also, the app could use the exposure and user trust of the App Store, as well as flourishes (pun intended) that Apple does not extend to PWAs, like haptics and a Liquid Glass icon.

https://flowery.app

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), how to advertise, etc.

Any ideas on marketing are welcome.

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

Have built the SDK and some apps like an HN Client, ChatGPT client, Claude Code permissions sidekick, RSS Reader, some games etc. (all in the same above repo)

It has 8x less powerful hardware than a modern raspberry pi but runs Linux with an eink display, wifi bluetooth and a good battery life for $100 or something.

I did the first Show HN a few days ago (https://news.ycombinator.com/item?id=49083987) but it was sadly left without attention.

Also getting curious about mechanisms to prevent damage from high temperatures in the short term. There's a project over the Great Barrier Reef I've been digging into what mechanisms they're using: https://barrierreef.org/news/explainers/what-is-cloud-bright...

These were stone memorials placed where someone was killed, especially in the UK. Most of them are 18th-19th century. Some are lost.

After watching a YouTube video about it and finding there was no definitive list, I registered https://murder-stones.org on Friday night and fired up claude code. There is very little on Wikipedia. I'm collating all the snippets i can find. There are a bunch of references I have collected which I'm sorting through with claude which has now run out of credits!

I have been more focused on finding new stones than fleshing out the stories so far. I have a pile of sources.

I have been researching manually for tidbits and feeding them to claude and asking what else it can find. It could find 8 to begin with but my research has got me up to around 33. There are some artifacts of that process still on the site... but it's day 2.

Its still a bit janky, but it's only day 2 really. Stack is a csv file of maybes, being sorted into sqlite, generating a static site with a python script, push to github, host on netlify. I also have a quick local flask app to enable me to hand edit the db and force a rebuild

https://murder-stones.org.

I would love to hear about any leads!

I've been building this for a while but I'm working on getting my first 100 users now which is my first foray into the marketing/sales side of things and any tips would be helpful. Also I didn't realize until later that the name, while I think is pretty cool, might be extremely poor SEO? :-)

I also think that these kinds of post-app apps are a curious idea and will become more popular, although likely (hopefully not) through sms as the communication medium. I am off this week and plan to write some stuff about it but it feels really cool to remove the terrible CRUD UIs entirely from this part of my life. I tell my friends that even if it doesn't take off I'm never shutting it down because I enjoy using it over myfitnesspal/cronometer/macrofactor etc so much.

Inbetween that I've been working on a "software house" (don't know how else to describe it). Pretty much codex/claude running on a VPS with a web interface and the ability to actually build and publish software / webapps etc.

It came from me sitting on the train on the way home and I had an idea pop into my head for a pebble watch app, I wanted to build it and test it there and then as I still had about 45 mins left. I know you can run codex against git repos in the cloud but I didn't want to faff with that (and last I remember the allowances for this were much less generous). It's been really fun, probably many things like this out there but it works exactly how I want it to. I plan to open source it once I've tidied things up a bit more.

Written in Swift, it consists of a SwiftUI browser and a Mac/Linux server and CLI. Shares are automatically discovered via Bonjour/avahi and also published as OPDS feeds.

It can import Calibre libraries and has basic support for managing books on Kindles, but I’ve only tested it with a MTP Paperwhite as that’s all I’ve got.

https://github.com/MattKevan/Stacks

When? Is a timeline game I've been working on for a bit. It's a board game I love playing with my family and I wanted a slicker mobile version I could play with them.

I just revamped the collaboration portion which is a patchbin service: https://pr.pico.sh

As part of that I work im also iterating on the ci/cd solution we are calling pici: https://ci.pico.sh

AMA

As a climber myself, to climb effectively, one has to review their own climb, and with other people. 4D video, body positions across time, is very helpful in improving climbing. I managed to get a reasonable result (far from good) from one video, rather requiring multiple camera angles.

Haven't gotten to monetization yet, but I am enjoying every moment of making it.

A read only preview at https://kmcheung12.github.io/climb-preview/w/ae43c6e5

I ended up designing a specialized variant of LPT that works well for Playwright test suites. It's now used in WordPress's Gutenberg project, where it cut test runtime from 35 minutes to 23.

The algorithm is called SALT. Here's the detailed write-up if you're interested in job scheduling:

https://blog.flakiness.io/posts/2026/salt/

https://tokenpony.dev/

It has a few potentially interesting side effects:

- enterprises can plug their preferred LLM into the SaaS they use.

- self hosters can extend their rigs into the web.

- simple SaaS products can offer LLM integrations without their entire pricing model being upended by LLM hosting and infrastructure.

- we can all live like Ender in Xenocide and have a personal AI that has context on everything we are doing.

- have a no op provider for people who are anti llm.

AI is making it possible to go after bigger clients so the strategy is to focus on marketing and going upmarket. A lot of new features to add and things to learn as you move up to bigger customers with larger contracts!

[https://www.zigpoll.com]

Contextify (https://contextify.sh)

It is very flexible, you use it the normal flow of CLI AI conversations:

   1. Resume unfinished work → "where did we leave off on that?"
   2. Recover the intent/scope → "what was the actual goal of this whole effort?"
   3. Verify it got done → "did we ever finish that, and which session proves it?"
   4. Recall a fix → "how did we fix this the last time it broke?"
   5. Reconstruct a decision → "why did we go this way instead of the other one?"
   6. Branch/PR archaeology → "what was this branch even for?"
   7. Recall a plan → "what was the plan we landed on for that?"
   8. Activity over a window → "what did I ship or close in the last few days?"

You can self-host your database to keep it local and sync your history across multiple computers. The local server is source available under FSL-1.1-Apache-2.0.

There are macos and linux clients, and I'm pretty close on a windows client. All share a common Swift-based core.

- All our shipments in one UI (instead of searching trough our mail boxes or going to several merchant apps/sites)

- LLM processes update emails, but everything can be manually adjusted (or created from scratch)

- We have a bunch of destinations we order to (work, home, different pick-up spots), this lets me see where I have to pick up and with which pick-up code

- Real-time sync in case we update something, the other person sees it immediately

- PWA, with animations, feels as good as native on mobile

- $0 running cost (I only paid for AI sub when vibing this)

Desktop: https://imgur.com/a/HD9mCIr Mobile: https://imgur.com/a/EAuJiqH

https://tandemonium.jimandi.love

Steam play test: https://store.steampowered.com/app/4482940/Tandemonium/

Open source: https://github.com/petegordon/tandemonium

It's a few classes of C# right now that parses a folder and auto generates the navigation, links, titles and summary off of the folder/file structure for the 1st level and then subsequent depth is mapped to individual items in the list view not on the nav bar (although I did that too, it looked weird with higher depth). So if you have a folder with 3 files and 2 additional folder you get 5 links in the nav bar, 3 content pages and 2 list pages. No other setup is needed. No llm written code, but I used deepseek v4 flash to ask various questions and get samples of some things.

I forgot just how much depth there is to exploring a simple problem. Loving it!

I love the hardware because it's the only keyboard I've been able to find that keeps a live Bluetooth connection and lets you toggle back and forth between USB and Bluetooth instantly using only a keyboard shortcut. That means you use two computers, and switch back and forth as fast as you can type. Years ago I also added a feature that changes the backlight color based on the active connection, so you can instantly tell which computer your typing will go to. I haven't been able to find any other keyboard that's quite as nice.

Lately I've spent weeks using an LLM to update the extremely old keyboard firmware to the latest firmware of its components (e.g., Circuitpython, the BLE firmware, the boot loader) and implementing all of my dream keyboard features that I never had the gumption to spend hours implementing pre-LLM. I finally resolved years-old bugs, and I added things like layer-based backlighting (so that the individual keys with relevant functions are lit), a better battery gauge, better sleep/suspend timing, backlight calibration, better debounce, and so on.

I've also upgraded the hardware and added batteries to each of the keyboards (I have three of these, one at home, one in the office, and one for travel).

It has been a very satisfying project, finally scratching a years-old itch.

The general thesis on identifying architecturally interesting areas on the golf course: https://golfcoursewiki.substack.com/p/i-spent-the-last-month...

Identifying dynamic golf design so you get more interesting play on the same course: https://golfcoursewiki.substack.com/p/friday-pins-vs-sunday-...

Measuring the addition and removal of hazards and how it dynamically affects different skill levels, and how to measure that: https://golfcoursewiki.substack.com/p/measure-2000-times-cut...

How I created a golf dispersion pattern generator -- which I made open source -- so that it can be improved, because the golf analytic companies already have the data and almost certainly won't share it: https://golfcoursewiki.substack.com/p/how-to-bake-a-dispersi...

- https://headsnap.io -> a platform that you can generate images of yourself based on 4 selfies.

- https://quantiq.live -> a service providing financial and historical data for stocks, as well as government trades.

- https://aivestor.tech -> an AI agent that picks small/midcap stocks and trades them using Alpaca API. It uses Reddit, news, polymarket, Google Trends and many other data sources to take investment decisions.

- @Polyglot_lingua_bot -> a voice-enabled Telegram-based bot that can help you learn new languages.

- https://select.supply -> a directory of carefully-curated and well-crafted products.

All of those allowed me to quit my day job and live a comfortable and flexible life. I still invest time in maintenance and adding new features, but I love coding, marketing and everything that comes with promoting and selling a SaaS (and I also have a serious addiction for Stripe notifications).

On top of that, I developed my own software agency where I help clients build and scale software (https://bitheap.ch).

Most of my time lately has gone into Flippd, its successor, which we recently soft-launched. We’ve also released a tech demo that uses custom computer-vision models to identify a pinball machine from a photo and extract the player’s score.

You can try it here: https://flippd.gg/scan

My primary target right now is e-commerce due to rich data streams, however if you think your business would benefit from this tool, I would be happy to connect and discuss it.

https://safetyevidence.org

It is the most comprehensive collection of benchmarks of the safety, ethics, and values of LLMs. I also aggregate sparse safety benchmark scores into a global ranking by optimizing the global ranking to maximize correlation with individual benchmarks.

On a walk and wonder what species is shading you? Curious if the city thinks your boulevard tree is as sickly as you think it is? Find your spot on MSP Trees.

It's been fun working with some public city data and thinking about how to normalize information across different municipalities. Community doesn't end at city boundaries, but municipal GIS data systems sure do. I'm hoping to build tools like this for some more areas if I can track the data down.

https://github.com/javimox/asf

https://smolenv.com

also has minimal implementations in clojure, go, php:

https://github.com/smol-env/smol

cheaper, faster, less peak RAM per task than OpenCode, Hermes, Codex, pi:

https://smolenv.com/t/nested-template-includes-60636/

https://smolenv.com/t/duckdb-sessionization-23811/

exploring what the minimal setup is for an agent to work well

My core hypothesis is that LLMs are trained to write consistent code (good for a billing function), but they also express design through code, resulting in consistent design as well.

Diffusion models are just now good enough to do UI, and are trained on a much wider set of visual data, resulting in more unique outputs. LLMs are now good enough to convert images to code very effectively, so the end result is better even though you have to do a conversion.

Here's a page detailing the standard flow: https://diffui.ai/blog/show-hn

And here are a couple sample sites built with it:

https://html.non.io/tarot

https://html.non.io/neonRamen (note - not optimized for mobile)

And here are a couple files showing the designs (requires sign in):

https://diffui.ai/app/canvas/9e03f5c2-91c5-4f96-8f08-b8086e5...

https://diffui.ai/app/canvas/95934269-5dc8-4145-a33a-d3a4dc2...

Happy to answer any q's!

Current goal, which I've been working on for a bit more than a week now, is to add support for controlling the RDP (the part of the N64's GPU that actually does all the rasterization), such that programs can actually draw triangles. I'd already implemented the control registers, so the current work is defining all the RDP commands, along with documenting what they do and how to use them — which means that I need to fully understand what they do and how to use them, and that's been a fun rabbit hole to explore.

I'm currently about halfway to two-thirds of the way through defining packed structs for all the RDP commands, then the plan is to build a CommandList struct with methods to build RDP command lists and validate that they make sense (make sure all the triangle/rectangle rendering commands have all their subcommands in the right order, make sure you ain't calling them without there being a framebuffer defined as the rendering target, make sure the needed synchronization commands are in place where needed, etc.). Then that should hopefully be enough for Zig64 to draw its first triangle :)

----

¹: https://fsl.yellowapple.us/zig64

Through the non-profit that collectively owns OBA, I've been working on a managed services offering to help transit agencies adopt the software, which has historically been beloved by users, but a real pain to set up and maintain. The software, cleverly named OBA Cloud, turns what used to require a month-long engagement with a transit consulting firm into a 15 minute, wizard-driven process.

The best part is that since all of the software is free and open source, a transit agency that decides they love OBA but wants to be locked back into an expensive contract can always ask a consulting firm to run the software for them.

Since last month[1], we've added a number of great new features to OBA Cloud, like broadcasting critical alerts to all riders in the system via push notification, and support for Live Activities on iOS.

We're hosting four new public transit systems over last month, and are continuing to make terrific strides on our other marquee projects:

The iOS app update went live, and our riders are generally loving it: https://apps.apple.com/us/app/onebusaway/id329380089

The new Android app maintainer is gearing up to release the biggest new version of the app in a decade: https://github.com/onebusaway/onebusaway-android/

Our GSoC interns are continuing to do amazing work on their projects, including the next generation OBA API server, Maglev: https://github.com/onebusaway/maglev

We're always looking for more folks to contribute to the project, across a variety of disciplines (ie not just engineers!): https://ossvolunteers.com/organizations/open-transit-softwar...

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

And today I knocked out an improved trmnl plugin for Japanese flash cards at my wife’s request as she liked the native one from trmnl but it lacked furigana https://github.com/simonjgreen/trmnl-japanese-vocab

Note: I let AI do the vast bulk of the work on both counts, and I ideated, architected, and bug fixed. I do love AI coding hobby projects though, when you have an idea for a thing and know exactly how to put it together but don’t have the time to raw dog the whole thing.

Each instance gets its own persistent file system, root SSH access and a web terminal. The goal is to let an agent build skills with experience rather than start from scratch on every task.

I started with Hermes as the first harness and now exploring Prime Agent. You can use it for a personal assistant, use it to build LLM wiki, connect it as part of an agent team, or run any coding agent on the cloud with dangerously skip permissions.

I’m also working towards a more general-purpose agent setup that can connect to channels such as email, WhatsApp, Telegram, Slack, Buzz.

It's an externally orchestrated (meaning it's not the agent running the loop) spec driven agentic build system.

A bunch of buzz words but essentially it's a tool you use as the last step after planning your work and writing a spec, to actually have agents write the code.

But it happens within an orchestrator that is durable and which coordinates layers of agents to build -> verify -> review -> triage -> fix -> verify fixes , until the code you get as a result is as close as possible to exactly what you specified.

So you can plan however you want, use whatever harness or agent etc and then just delegate the build to the engine (MCP server or CLI)

You can mix and match models from any provider for any part of it.

I'm building this because I think micromanaging agents is what causes AI burnout and because I want to be able to plan work, walk away and come back knowing it's been correctly implemented.

https://engine.build if you want to be notified for the launch, it's going to be free to use and fully OSS (Apache 2.0)

A modern database client with dashboards, saved queries, workflows, and yes, AI built into it.

I've focused on building brilliant UX over the last year, and it has paid off. I've had two emails saying that they have cancelled their Jetbrains subscription for DataGrip which has been so validating.

It's been a labour of love and I'm super happy to have disrupted even a small part of the ginormous market that is database clients.

[1] https://dbpro.app

One surprising finding is how few people are interested in real-time voice interaction (transcribing, dictating, conversing with assistant), so that's been removed for now.

* Native and small. * Private by default. * Terminal-safe. * Agent-ready. A built-in MCP server exposes read-only tools (browser_open, browser_read, browser_list_links). * Configurable.

[0] [code] https://github.com/meerita/puma-browser

I am still far away of 1.0, but I've been using it every day since. It's open source, you can compile it and use it as you want.

Every week I try to finish more features.

I bought that printer in order to print parts for two other projects: a baby monitor (security camera) and a hat-mounted teleprompter monocle. Both using COTS part and running Yocto-based open source images. All affordable products in both of those sectors are completely untrustworthy or otherwise unsuitable for my requirements, since one of which is total replacement of the firmware with my own custom versions.

In my day job, I am a principle embedded engineer consultant working on distributed embedded systems, so all of the above software will be relatively easy.

The mechanical work will be the most challenging, as I am presently only using OpenSCAD. I would entertain suggestions for alternative open source CAD solutions, but I hope to recruit a ME (or two!) to help drive that portion of the work to completion.

A work in progress, and will stay so for much longer, I guess.

https://alint.org/

https://alint.org/blog/why-alint/

It is usable stand alone but also through an R package:

https://bobjansen.net/faster-than-data-table-introducing-ibe...

It performs better than data.table in my benchmarking on a wide array of tasks and is competitive with Polars on low core counts.

You can try it out here: https://harmless.atomic14.com

I'm planning on doing it Open Vibe Code. Add an issue and I'll set Claude on it.

PRs will be rejected out of hand. I don't want your code. I want your words.

It's just a bit of fun to see what's possible.

There are numerous UI form builders. And Xlsform for ODK and KoboToolbox but nothing I could find that is easy for humans and machines to grok. So I wrote a DSL in Ruby to see if it could be done. The language is mostly described at https://srp.solutions and some example usage and implementation at https://srpsurveys.com/

https://soc.bio

It takes inspiration from Python, Rust, Go, and functional programming. It's oriented toward readability, safety, and speed.

I'm finishing up the journey of completely self-hosting. Then I'll be tidying it up for an initial release.

It's a screen recording tool for Linux. The goal is to make it as fast and efficient as possible, while also being simple to use and install. It's just a hobby project that I am having fun working on. Here are some notable things about it:

- Written in Zig

- Uses Vulkan Video for encoding

- UI built with SDL3 and imgui

- Features recording, replay buffer, and screenshots

The reason I need a complete reimplementation is that existing graph layout libraries tend to be black boxes that you can't really fiddle with. If you want to tweak part of the algorithm, you have to fork it or write your own. With Eland, you can replace individual steps with your own implementation while keeping the rest of the algorithm unchanged. To ensure validity of the various steps, I've introduced contracts where every step specifies what properties it requires from the graph, which properties it promises to add, and which it invalidates, which I think is pretty cool.

The reason I need all of this is that I'm working on a system to display and browse through data lineage graphs. I've noticed through experience that existing graph layout libraries don't do quite what I need, so I ended up building my own.

https://tcpviewer.proxyman.com/

https://typequicker.com

I believe typing is probably one of the most important skills in 21st century for knowledge workers and yet one of the most neglected. Hoping to change that.

Anyone can learn to type fast, without having to think about or look down at the keyboard. We are building the best tool to help people get there quickly

It tracks explicit mentions of ~ 181 languages, technologies, vendors, etc as seen in job postings. The motivation was that GitHub activity and developer surveys describe what people use or enjoy, but not necessarily what employers are requesting.

I’ve been working up reimplementations of Nikoli puzzles to host on my personal blog, the goal is to work through the maths and then explain how it’s relevant or helps create a fun games. Nikoli is the magazine that helped create sudoku and made it famous - they have a lot of other pen and paper puzzles that are really fun to play.

I’ve also got two other open source tools I’ve built to help me work daily:

https://tajd.github.io/cofferdam/ which is a rust based cli tool I wrote to parse the ast of codebase and enforce architectural preferences - eg don’t reimplement design system for components down to DRY

https://tajd.github.io/projektor/ Is an ai native project management tool where I can plan work on the train and then have my agents pick it up autonomously. Bootstrapped it quickly but then have been incrementally adding more functionality to it. It’s like self hosted jira on cloudflare but much faster and has more agentic development tools. I added tooling around being able to autonomously work through epics, manage quality and fix identified bugs - https://tajd.github.io/projektor/agents/playbooks/epic-goal/. The goal being deliver useful features and then to ultimately surface the number of bugs identified by agents and users so that I can see the health of the project and figure out if I need to write more code myself or improve feature descriptions to reduce discovered bugs. I don’t think this is new at all but it’s reliable and done well, I hope.

https://tradeinsight.info/ti-agent

https://12seasons.nyc/explore/

https://www.gijsleijdekkers.nl/gltaudio/

I’ve been making interactive learning resources for myself - with wasm and browser simulation based labs (browser only interactive courses served from GitHub pages) to teach me topics from beginner to advanced

LLMs and systems intersection - https://kernelspace.naigap.com

Distributed systems - https://byzantine.play.naigap.com

Shipped "bring your own translations" feature this month, built together with a customer who wanted Localhero for the workflow and review layer but writes some translations themselves. Otherwise smaller improvements and marketing. Better Lingui support, for example: projects using explicit IDs keep the source text in the source locale's msgstr instead of the msgid, which our CLI got wrong before. Also wrote some blog posts, a comparison of GitHub Actions for i18n and a guide to auto-translating gettext .po files in CI (Django, Phoenix, LinguiJS). Content is slow going but it seems to be how people find us via perplixity/gemini/chatgpt.

On the side, https://infrabase.ai (AI infrastructure tools directory) grew ~16% MoM. I leaned further into the agent angle: added a public query API plus llms.txt/agents.md/etc so agents can query the directory directly, and exported the full dataset to a public GitHub repo. Starting to get som traction and people wanting collaborations.

You can build out and trade hardware in the master equipment list and immediately visualize how any changes impact mass, power, propellant, and link margins, or break power or data interface compatibility. You can also play around with orbit and operating modes to optimize things like orbit average power.

I'm hoping it can be useful in rapidly iterating early stage spacecraft designs and weighing system-level trade studies across CONOPS and hardware. Its still very much a work in progress so I'm always open to feedback.

People seem to love the concept so far and are starting to sign up, now just need to figure out how to get them to actually use it

Also hacking on something similar to YC's QM but designed for small non-profits to ease as much back office work as possible.

github: https://github.com/iroblesrazzaq/RallyClip website: rallyclip.app

I'm working on model performance and an iOS app right now; would love feedback on the macOS desktop app.

On July 24 2026, all major eSIM providers including Akariq faced disruptions. However, Akariq was able to serve all customers even during the downtime either by switching to backup resources or issuing replacement eSIMs free of cost. Some customers of major providers like Airalo experienced serious down time. I wrote more about the incident here and what I am striving to be better in terms of automation etc [1].

One review from a customer in China [2] made all my effort worth it. They said that they were able to use Akariq to access Gmail, WhatsApp etc around the GFW. It even worked smoothly in areas like Beihai and Weizhou island apart from the cities. Tethering with their laptop was helpful too.

[0] https://akariq.com/

[1] https://akariq.com/en/blog/akariq-backup-esim-service-interr...

[2] https://akariq.com/en/esim/cn/

https://storywatch.org

https://github.com/fallout2-ce/fallout2-ce/

I designed Silent Shark to be the sweet spot of minimalism meeting realism of dials and procedures (like a simulated Torpedo Data Computer) that scratches my simmer geek itch without being impossible to write the game myself.

https://store.steampowered.com/app/4705650/Silent_Shark/

Browser demo: https://silentshark.app/alpha

Https://pasclaw.dev/

https://github.com/kofta999/tensou

I always get frustrated when using local file transfer tools like:

Dukto: was my personal favorite, but is tiring to run cross platform, and most importantly does not support transfer resumes (so if copy got cancelled/disconnected at 99% you either have to copy again or search for the diff and copy it manually)

LocalSend: pretty good cross platform support, but does not work when connecting 2 devices using a LAN cable, and resume support is poorish

So I'm building Tensou to be an alternative that doesn't compromise all these features. Supporting resumes, folder syncing similar to rsync, cross platform (well I don't have a Mac to test on but it should work, and mobile support is planned)

Performance wise it's on par with Dukto and even slightly better with large files (and I'm still working on optimizations for small files too)

Would like to hear HN's feedback or what other features should I add? My goal with Tensou is to be the best, most performant and feature rich local file transfer tool ever.

About to release a fun paid version. All contributors get lifetime free access.

Better running agents run longer, they need better plans. (is my bet)

https://snaketron.io

https://github.com/lopatin/Snaketron

At this rate I'll have it finished by the end of the next decade.

The control plane is entirely in Elixir, using Jido & Oban to help power tools it gives an agent to get your app deployed. Uses k8s currently for the infra, but I've made the app => spec => build => deploy layers completely agnostic so we could switch out providers & methodologies in the future.

Looking for people who want to throw apps at, it's still early so no guarantees yet. You can find the website at https://infrastry.ai/ (still a brain wreck of ideas, working on it!) and I made a Discord for feedback at https://discord.gg/sBkS5ZMM3t

FutureOfGaming.com - In-depth weekly analysis revealing what's actually being developed in gaming, from new player experiences to technical innovation. Over 1,000 gaming patents covered since Nov last year. Every Tuesday for patents and Thursdays for filed.

ContentCreators.com - education, free toolkits, tools directory, job board for content creators. Recently also set up creator profiles to build out a creator directory and connect with brands.

WebsiteAudit.com - does what it says, run my websites through it to identify gaps - anything from performance, security, SEO and get recommended fixes. Looking to expand to also add brand AI visibility, hoping to launch soon. Still in testing

https://www.cangjieworkbook.com/

[0] https://totemkb.com

In particular: an image viewer with a small suite of extra functionality; and a browser extension for cleaning up URLs and then bookmarking them in a more organized way that I might actually use meaningfully.

https://sharpee.net/ https://sharpee.plover.net/

It was never really meant to be an SDK of sorts that other PS1 homebrew projects would pull as a submodule and depend on, but since it more or less became one I am likely going to split off the examples from the "core" (headers, CMake build scripts and tools). I have also been asked to add more examples, particularly on how to play sounds through the SPU and access the CD-ROM drive, and may cover I/O on some PS1-based arcade systems in the future.

It also contains tools for scouting casinos, logging sessions, calculating effective profit-per-hour based on table rules, and other things a professional would need.

I'm in the process of polishing it up, and am aiming to launch Fall 2026. Current pricing plan is to be ~$10-15 per month for the pro tools, but provide the offline capabilities, lesson plan, and learning tools completely free without ads or weird gimmicks like a limited number of lessons or practice per day.

It is a research-first method for designing or reviewing SaaS products. Its central question is: What customer outcome matters, and what evidence proves that the product delivers it?

Idea or existing product → Research real customers and current work → Identify their Jobs to Be Done → Design the minimum safe workflow, define the interface and system behavior (with a sophisticated scoring system) → Validate the workflow → Implement vertical slices → Observe proof of customer progress

Aside from that, I've been getting into building hyper-local services around public data; it feels really rewarding and relatable to invest more locally!

Already up and running: https://hailpass.com/?ref=HAILHN9 (ref code there knocks $10 off the season price) as a "season pass" for latlong/street address level-targeted hail notifications, built specifically for damaging-size hail (not just _any_ hail) on the Colorado front range. Email is free, texts are on the season pass model.

On its way, likely first ship today: https://denverbroomsday.com, same season pass model with same free email/paid-per-season text split on reminders to move your car before street sweeping days in Denver.

Just drop in your HAR file and get immediate insights into the SAML related events.

Recently we also got European funding and the project got some traction. Very exciting times ahead.

https://grandpacad.com

Most recently I made a portable AQI meter, since the air quality here in Central Oregon can quickly get bad.

It's a small 3d printed box containing a rpi pico, an 18650 battery, an e-ink display, and a SEN66 sensor.

I hit a button, it turns on, runs the sensor for ~40 seconds to get a good reading, displays on the e-ink, and then turns off. So there's zero power draw when it's off, and the battery lasts for ~1500 readings. Accuracy seems fine, the AQI, temp, and CO2 readings all match my permanently placed sensors inside and outdoors.

Other projects include using some of the old leftover robot scrap to automate irrigation in my apple orchard.

it's for people who dont own a home server, don't like to keep their laptops open and working, don't want to trust on magical stuff openclaw does and instead would like to work with the usual harness they are working with day-to-day, don't want to be vendor-locked (crush/opencode/glm-5.2 and other models/providers support to come) but want to have a way to execute ideas while being away from their laptops

the demo is available on testflight and going to be released to play market soon as well

it's very alpha version but it's functional

lmk if anyone would like to test

The first attempt was a full on x86asm->webasm transpiler which ran into some difficult stack issues.

The second attempt was successful via conversion from x86asm->c->emscripten->wasm [0]. It plays pretty well on mobile and just about any browser now.

Fair warning it is pretty difficult to win, unless you can figure out where the enemy weaknesses are [1].

[0] [code] https://github.com/gottebp/alan_parsons_project

[1] [play] https://particlefield.com/projects/alan-parsons/game.html

I have had quite a bit of usage: https://smalldocs.org/analytics, which I'm very proud of, with many developers using it week after week.

It's free to use by the way.

Code is open source at: https://github.com/espressoplease/smalldocs

This is meant to be something that will help business teams be better able to communicate what they want, while producing ready to deploy tech artifacts that do not rely on AI.

More importantly, I have been working on being a Dad - something we were told would be impossible naturally. Way more fun than being in front of the computer - our little one is nearly six months old now, and sleeping through the night until usually at least 8 AM, starting to roll over and enjoy tummy time more, and bringing smiles everywhere she goes.

Hosting an XGBoost-model for MLB totals predictions. It runs every thirty minutes: incorporating weather at the hyperlocal level and joins with player attributes that are provably affected by that weather. It also provides advanced decision-making tools with a Kelly Criterion calculator built in. Model still needs some calibration for bet-sizing but is very close to production-ready.

Robust historical evaluations available at https://ballcast.app/validation

https://testflight.apple.com/join/mqfhpmHY

This work is motivated for my lifelong love for chess, my passion for Apple hardware and software (not as much as before, sadly), and my frustration of not having an Apple-native app comparable to ChessBase. My disappointment with the trend of recent macOS apps using Electron or other cross-platform frameworks instead of the native toolkits is also a factor. I miss the days when Apple users demanded more from macOS apps.

My aim with MBCA is to create a serious chess app that satisfies the needs of everyone from club players to professionals, with a native Apple look and feel and iCloud sync. Currently the app supports the iPhone, iPad, Mac, and Apple Watch. I hope to make a visionOS port later. There is still a lot of work to do, but I’m having a lot of fun developing it, and I already find the current version very useful for my chess training.

The name, in case you wonder, is from a short story by Gene Wolfe, my favorite science fiction author.

## Tab Highway: Browser extension focusing on the UX/process of decluttering

It turns tab cleanup into a game.

When you pile up too many open tabs or whenever you want, it opens a night drive where each tab is a road sign you drive through or send to the trash.

[GitHub](https://github.com/pravj/TAB-HIGHWAY)

This is still a work in progress. It works on my machine, but not fully distribution-ready.

## A short satirical blog on the overly-expressive/interactive web experiments fueled by coding agents.

Ironically, the project listed above falls in the same category.

[Woodworking Has Been Achieved Internally](https://hackpravj.com/blog/woodworking-has-been-achieved-int...)

This is a complete, bottom-to-top rewrite (front- and backend). It's a huge improvement. I used an LLM, quite a bit. It's been a big help.

We're in the last stages of the first-wave testers. This is the one that affects the app UI. After this, we expand the test, and do bug fixes only.

Also, we need to start taking screenshots and app previews for the App Store. That requires setting up a test server, with anonymized (fake) users, so we don't compromise actual user anonymity. It's a bit of a pain, but it has to be done.

And taking a second crack at a feature flags with https://quonfig.com because I seem to be unable to put this problem down and finally feel like I have the right git native and agent first approach.

Over the time I've built a massive collection of assets from various stores and stuff I've built.

The solutions for managing assets seem to be largely in house tools studio build themselves and don't share.

So I'm working on a digital asset management system that plays nicely with the tools I use; unreal engine, unity, and blender.

I don't have anything public yet, but hopefully for September or October edition of this post!

Fed up of wading through a metric oodle of waystones and tablets to figure what best, along with a billion stash tabs full of a zillion items.

I'm making a tool that scans your inventories and lets you rank and analyse things based on their affixes, so the best ones according to criteria you set pop out at you, minus the hours of staring and thinking.

Hobby project, so full on vibe coded zero code review type stuff. If it works, thats good enough. for now, anyway.

KimiK3 is the weapon of choice for this one, and its doing pretty damn good!

https://docs.google.com/document/d/19e3HfnK1lNHHBef-5c-KvNdD...

The overall idea is to work/write at an higher level of abstraction where you work with "ideas" (just small paragraphs).

You can move them around and basically restructure many/whole paragraphs by simply changing few words.

The final text is generated by an LLM.

LLM that has the whole context so you can ask it questions, but more importantly it can provide you feedback

Limiting screen time has been a primary goal in my household and has been going well. But I wanted something that would take my kids hours every month that

1. isn’t on a screen 2. educational 3. fun

https://files.maxleiter.com/f/gimp-on-ipad-optimized-Dyuygd6...

Every day, players answer 5 questions that require estimating some quantity, such as distance, year, cost etc. Then you can compare against answers of other players and the real answer.

Working on finding the right balance of questions that are both fun and also help understand facts about the world.

It's been a lot of fun, Godot and agents have taken most of the pain I remembered from my childhood attempts at game dev out of the equation so I can focus on game mechanics, art and lore. I'm almost ready to start soliciting external playtesters (which I'll admit is a bit stressful), I just need to clean up the UI/card templating/art/tooltips/etc so the game is accessible out of the gate and I don't churn for reasons other than the gameplay not being tuned yet.

hack music

Basically, I'm collecting public data (official registries, job boards, company websites, linkedin etc) to surface sales opportunity signals, like leadership change, new branch/market entry, funding rounds, etc.

https://sponder.app (Live) - an RSS and podcast mutator. Filter feeds for what you want, merge, time-delay, and drip articles on a cadence (I like to start from feeds' beginnings). For podcasts, detect similar metadata to previous releases so you can skip reruns.

https://tellmeapenguin.com (Close! Come help test it) - Endless mad libs about whatever you want, and if it's a good story, you can keep writing more chapters. The kiddos love it, and you can share back and forth with grandparents and whatnot to keep sillily in touch.

https://nounogram.com/ (Web is live, apps soon) - Hybrid nonogram and crossword puzzles. Shade the grid to find the layout, then add the words where they fit. I built it to make the kiddo practice handwriting, and then it was more fun than I expected.

https://getyarnt.com (Free until I ship the Stripe integration) - A task tracker that's actively hostile towards you having tasks. Started as a joke, but I'm using it to track my own stuff and really enjoying it. If you have a manager who likes assigning you work, tell them to get Yarnt!

All of it's on https://hahamoment.dev/ in the likely event you don't need any of this but do want to turn on a light.

Additionally:

Live graph reconfiguration Timed events Easy simd support Support for non-mmu based architectures Imperitive configuration management and querying at the single runtime level. Can be compiled to wasm, and run in the browser (w/ coors headers). IO/user interface and any GUI is done via typescript.

https://www.fabshack.io

It answers two questions that are usually handled together inside the fitting room: “How might this look on me?” and “Which size should I order?”

The virtual try-on renders the garment using a shopper’s photograph. The size recommendation component estimates the users measures, use the brand’s size chart estimated measurements and suggests a size plus a fallback.

The merchant integrates both through two widgets.

The idea is you have a set of sources (e.g. Github, Google Docs, local file system), a bunch of transformations (templates, apps, llms/gen-ai, simulations) and sinks (communicated through changesets). The platform is like a cache layer that connects these together and allows for a graph of operations (source->executor->sink->source->executor->etc.) which allows for tracing the lineage of assets through a system.

It's an impossibly large vision made barely possible with agental coding assistance.

Which is an app and audio plugin to take and send pictures to a DAW tracks and have them stored in the project file.

Not vibecoded but I must say Claude was a big help to finish and debug my C++ code (which I didn't know before this).

It uses functional programming and event sourcing to try and effectively "solve" modern distributed web application development, so that your app code in this language can be extremely simple but not have bad architecture and gaps.

I'm probably oversimplifying the complexity, so I don't even know if it's feasible, but it's pretty fun to give Claude my crazy ideas and see what happens.

https://github.com/georgestephenson/beck

https://github.com/eliasson/garanti/

Just this friday I wrote an article that took a look under the hood.

https://markuseliasson.se/article/under-the-hood-of-a-gleam-...

I've been working on this for a while now. It creates a sort of AGENTS.md or CLAUDE.md table for your database which holds all the joins, definitions, formats, and relationships, as well as what are popular criteria sets and combinations.

And it populates it into a bi-directional visual (round-trip) SQL editor. Make changes in the UI or SQL text, it goes both ways.

It's a single HTML file.

Send the service number a text message like "call Dave in 2 hours"

and then in 2 hours you get a text back that says "call Dave"

Open in private beta if you're interested email:

textreminders@hazybridge.com

It's a bit like NYT Spelling Bee, except it's multiplayer and only your best (longest) word counts toward your score. So, instead of trying to find as many words as possible, the game is more about finding one unusually good word.

Funny timing, I just made my first Show HN post for this a few minutes ago: https://news.ycombinator.com/item?id=49235347

https://anopheles-genomic-surveillance.github.io/home.html

Personal: Local models. Agent harnesses. Track cars, turning wrenches.

Had agents build recently:

- Photo catalog app with all 100K photos in my library described by a local 9B parameter model (it is absolutely amazing and my favorite personal project in terms of genuien impact)

- Generic RAG layer (vector embedding + FTS in SQLite with RRF and document ingestiation layers for 1-2GB knowledge bases to power agent context for stuff I am interested in, neuroscience and philosophy is where I spend time on this right now, and basically every AI research paper publicly available to help agents tinker with local models). This is especially useful for local models, but it even helps frontier models because they can freely churn through without a bunch of web calls and such when you are on a topic thread or research.

- Qwen 3.6 35B A3B clean-up proxy, achieving a clean thinking + tool calling A3B that I can leave running for 24+ hours. This particular model gets stuck in long reasoning chains and needs encouragement to get on with it, especially on context tasks. It actually reasons well but then starts second guessing and loops. Built a deterministic framework to inspect its thinking and make it wrap its thinking up if it gets stuck and also to trigger calls to external models and inject solutions to problems when it gets stuck. The agent sees the solution injected from a remote model like it is its own thinking, kind of a subconscious it has no idea about. Metacognition in models, it is wild.

DSV4->GLM->Kimi is the "phone a friend" external brain pathing I built. As far as I know no one has shared all of the bugs I have 'fixed' in my project and gotten local Qwen A3B this reliable.

And second thing im building is out of sheer frustration as a father of 5 in the school info management - https://www.classtable.org - aims to be a full school management software which is easy to use for both school staff, students AND (personal itch) for parents to keep an eye on their childrens progress

With the updated frameworks in place, this ancient browser becomes able to access the modern web again! Even webapps like Figma work!

https://github.com/Wowfunhappy/WebKit

(As I make clear in the Readme, Claude wrote this code, a project like this would never be feasible otherwise. My main job has been to decide on larger infrastructure questions and find bugs and make them reproducible.)

SystemG - An agent-friendly general process composer.

- https://sysg.dev/

- https://github.com/ra0x3/systemg

- https://docs.rs/systemg/latest/systemg/

It’s pretty fun! It might even work on your local library (I got carried away and spent a while making it work on a few thousand round the world - you can see the coverage here: https://leafle.nanosheep.net/coverage).

https://leafle.nanosheep.net

For us MacOS users that use Spaces and want to CMD+Tab only inside that Space, the only alternative was AltTab (that I could find) but it has so many more features and goals, plus I had performance issues with it remotely over HPSS which I use heavily so I've generated the simplest utility that only shrinks the CMD+Tab list per Space and nothing else.

https://github.com/emp/SpaceTab

https://github.com/joswayski/captures

Managed to snag a cool domain for it too!

http://captur.es/

Would love any feedback from anyone that tries it

Example: https://atlanta-fci.bop.doj.dev/program/65545-inmate-account...

https://metallian-photos.fly.dev

It's an Actix Web/Tera/Datastar concoction, hosted on `fly.io`. It provides the backing for galleries for my music site: https://crusty-metallian.net

Now, if only I could actually write something for the blog part...

I also bought some cheap gloves from harbor freight and used a needle to route fiber through each finger to make a simple power glove like thing which I think I can connect to arm arm to make a cool robot game. I think of the two I am more excited for the first but its much more work than the second and my day job is getting more exciting than I would like so by the end of the month I'll have had to pick one to finish.

https://app.ironcalc.com

In the last couple of months my partner and myself quit our jobs to work on that. I am pretty sure that in a year from now the world is going to have a fairly competent spreadsheet alternative.

My capacity is fairly limited but I am trying to build a community around it. Join us!

https://github.com/ironcalc/IronCalc

We're competing in October for the NFDA Innovation Award with it and looking for funeral home design partner(s).

I was talking about healthcare price transparency with a friend. He pointed me to a hearing in congress and I was surprised by how much I learned from one of the witnesses' testimonies so I built a "serendipity engine" for congress hearings.

First, https://agency.nu/ a personal agent platform for people who aren’t necessarily developers, but still want to connect multiple Gmail, Calendar, and other accounts and automate workflows across them. Spent a lot of time making the interaction easy and natural, so it supports chat, realtime voice and telegram.

Second, https://vinarium.one/ something I primarily built for myself to keep track of the wines in my wine fridge, when to drink them, and what pairs well with a particular dish.

Both are very much scratching my own itch, but I’m curious if either resonates with anyone else here.

Built overwhelmingly in vanilla JS with a couple of WASM modules for it.

It’s generally very performant across the app so far, but there’s still a handful of features that are functional but subpar in terms of performance that I need to address.

[1]: https://mlsync.ai

Because SPICE wasn't built for programmers in mind. The code in 0.1.0 is almost ready and I'll put the github repo public soon.

I couldn't find a good way switch them between different Macs, so I made https://github.com/MegaManSec/magic-switch. It's a small application which allows you to basically share the peripherals between Macs, and send them back-and-forth either manually or automatically.

A calorie tracker for iPhone/Watch/iPad, no subscriptions, no ads, integrates with Apple Health and fully open source. Includes optional AI features, either using on-device Apple Intelligence or BYO with Anthropic, OpenAI and OpenAI compatible services (eg self-hosted).

Still tuning it, but over the last month I've used it to lose around 10lbs.

I'm planning to put it in Testflight to avoid the 7 day signing expiration and improve iCloud integration, but don't have any plans to put it in the App Store. Developed with Claude Code and Axiom skills [2].

1. https://ecliptik.github.io/onigiri/

2. https://charleswiltgen.github.io/Axiom/

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.

If you try it out, please leave me some feedback :)

It was inspired by my wife having to carefully mask product photos for her online shop. Existing tools could remove backgrounds automatically, but didn’t give her enough control when the result needed correcting. So masking is a first-class feature, with SAM-assisted selection and a precise manual brush.

The backend and storage are self-hosted on hardware I own. Along the way I’ve had to solve some interesting infrastructure problems, including writing a Kubernetes operator that bin-packs GPU workloads across workers. I’m planning a technical write-up on the architecture.

All the agent hook guards I’ve seen can be easily removed by agents (and they often do so they can get going with the task). I made mine harder to remove, and I’m working on making it impossible.

I also made “nah” easily extensible. Just point your agent to the docs which ship with the CLI, and ask it to build a custom guard.

I’m working on strong Python and Typescript pseudo-interpreters so I can detect disasters in inline code with less false positives. Bash parser is already very strong.

This is a side-project that I want to be proud off. I spend a lot of time designing, not just coding.

[1] nahguard.ai

https://secchi.dev Secchi is Open Source Package Intelligence | python based

https://tuffcli.dev tuff is Capability lifecycle manager for coding agents | rust based

Both would be very helpful to be part of developer tooling. I built package intelligence when I need to monitor the downloads of my other personal project packages from package manager.

I have learned a lot over in terms of rust language, design patterns in rust, also how the ecosystem of AI capabilities within projects use cases and needs

That sounds interesting, give star to repo :D

Thinking ground up what AI agents would need rather than struggling later on with snapshotting live vms, or orchestration overhead etc.

rust-vmm proved really great for this.

https://github.com/instavm/tarit

It’s still in flux and a bit slow as I have to juggle it with my day job, but pretty excited to launch it once it’s good enough for a 1.0!

https://github.com/todone-run/todone

Recently went on an optimization bender that saw the index now become almost completely bottle-necked by CPU in the ranking calculations step. Pretty neat. Faster ranking means better results as queries run on a timeout.

Also working on making the search results more relevant by fixing jank.

Also working on some more commercial features, like the ability to monitor queries (e.g. for backlinks or brand mentions) and get an email when there are new results. Unsure if there's much demand for that, but I want the feature, so I'm buying it even if it doesn't make me yacht money.

What I really wanted was an infinite coding video, so I built one. Pick your IDE/monitor/ambience of choice, hit the Screensaver button, put it on a second monitor or TV, and enjoy infinite coding ASMR.

Recently added a Paper Mode which shows an animated quill that scrawls across a parchment for public domain novels.

https://hackerman.specr.net

https://github.com/blairjordan/pygmyhippo

https://amacrin.com

You tell it what kind of doc you want, attach any necessary links/files/repo paths/etc, then it asks you clarifying questions until it has the data it needs. Then it authors a doc and give you a review interface. You can approve, request more info, request changes, make direct edits, etc. Then submit and makes edits until and represents until you approve all sections.

https://github.com/jacquardlabs/viva

It pulls jobs from tens of thousands of company HR pages, and only keeps them for seven days (unless it sees that the job has been filled). No reposts. Only fresh jobs.

Besides that it has a resume builder, matching system, application assistance via an extension, job tracking software, and an interview preparation helper. It turned into some fairly complex software that I ended up learning a lot from!

If any of you try it, let me know what you think.

It now has power management, a launcher, iOS-inspired Control Center, an AI voice assistant (using OpenAI Realtime API), a tamagotchi-style app and I recently built the iBeer app :D

As it currently looks I need to design my own PCB with a modern LTE module and make it connect to all the peripherals. Thought it would be a nice project to get into electronics, soldering etc. Also really enjoying the constraints of an 84x48 LCD screen and how to implement "modern" technology like GPS navigation or design the UI for a music player.

This has been my work outside of work, which I spend most of my weekends on. It has gotten enough downloads (23k+) and traction to motivate me to continue.

I've been working on an AI Tutor or Primer that automatically generates Duolingo style curriculums. Planning to apply to YC after the next big feature release.

The current website is a rushed out MVP. It takes a significant amount of data science and prompt engineering to generate good courses, so it's taking me a bit longer to build the true vision.

I've also revived a project to design/implement a programming language. I'm slowing converging on a (keyword-less) syntax and (Beam-like) architecture that's starting to feel good.

A.I. generally shines when the steps are small and incremental. I would add that, when A.I. is used properly, generating code and hopping from one code to another, it should be better than any human already.

Very early. Tech: raylib-zig with Lua, loreline convos, shaders. Graphics in aseprite.

https://github.com/relativedb/relational-transformers

https://relationaltransformers.com/

You can read more about the architecture here: https://relativedb.com/blog/relational-transformer

I‘m still working on it and adding features to my other side-project which is a local prompt library (https://bearprompt.com).

* Automatically sets alerts when I favorite a stock

* Discuss and analyze stocks with AI

* Generate AI research reports

Would love feedback from other investors/builders:

https://getmarketalerts.com/

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

https://news.ycombinator.com/item?id=49079995

https://github.com/joseprupi/quantraserver

https://quantra.io/

I’ve always enjoyed solving observability and reliability problems, so eventually I decided to build my own take on the boring-but-important "is it actually working?" part of the stack.

It does uptime checks, cron/heartbeat monitoring, incidents, status pages and notifications. Nothing revolutionary — the goal is to make the familiar stuff simple, reliable, and pleasant to use.

It’s built with Rails and hosted in the EU.

https://watchcat.io

It gives agents the ability to find website design references to improve their design skills via the mcp - https://design.withfudge.com/mcp

You can also critic your existing designs against competition.

https://webmcp.today/

It's hosted on a VPS, connected over Tailscale, and has a realtime TTS server (Piper).

The Pebble has built in transcription, so my app takes the transcript, hits the server endpoint with three possible paths:

1. Deterministic response

The server looks for certain triggers from the transcript like "Add task," "Complete task," "Set a timer," etc that will run a simple function on server and write / retrieve to a database, no LLM call needed. It then responds with the TTS output and the watch speaks. This path is nearly instant.

2. Fast response

If no trigger is found, then it hits a gpt5.6 Luna endpoint, which decides if it can answer the query itself, or if it needs to defer to the big brother model. If it can handle a query itself, it usually responds to simple questions in less than 8 seconds. It's also good about properly deferring, very close to 100% after a few weeks.

3. Deferred response

The VPS hosts a Hermes installation, and for more complicated tasks or for ongoing projects the Luna router sends it to the Hermes agent. This is typically quite slow, as you'd expect, but remarkably capable. I built the voice app to cache a few lines like "this will take some time" which will automatically trigger if the router indicates it's deferring, and then will respond with the full response from Hermes once it's finished (sometimes minutes later).

Pebble has a quiet mode, and my app will only display the text response if it's on, otherwise all responses are run through the TTS. Piper is so fast that this adds almost no time to the response.

In only a few weeks this has become the primary way I set up tasks, review and close them, set timers and reminders, log my weight, check in on the progress of projects I'm running on Hermes, and ask simple day to day AI questions.

Since Pebble is open source, AI tools are very good at building it, and it's trivially easy to set it up so that you can just ask the model to deploy it live. It's an awesome experience to tell it to change something, and two minutes later, that change is on your wrist.

Very fun project!

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

Turns out integrating into a bigger IDE is much harder than just implementing a JavaFX view using libghostty...

Specifically, I'm working to stop working on them.

Added more widgets to Printable Mockups https://github.com/alexadam/printable-mockups & https://www.printablemockups.com/

I’m starting with the Waveshare ESP-32 watch. It has a great price tag and features, and an impossibly small battery for regattas that run for hours over two days. Designing it for super low power like this, no internet (regattas are often rural), and very high expectations (competitive sailors) is challenging and fun.

Ultimately custom hardware (probably Nordic based) will be in the cards, but for now I’m engineering a solution from what I have.

https://allthedamn.tools

I don't necessarily suggest that anyone besides myself use it. I open-sourced it to perhaps give other people ideas, but it is tailored to just my own needs (e.g., hardwired to use deepseek-v4-flash-0731 via FireWorks.ai; supports just the tools I need).

It builds around the concept of “wolts” running a lodge. A wolt takes the identity of a rodent (racoon, beaver or otter) and can inherit any supported coding harness: claude code, codex, opencode, etc. Each wolt carries a persistent identity and memory, so they always know where you left off.

woltspace is designed to help you host your apps directly from woltspace on your machine. If it works on your machine, it works anywhere. This is done through Cloudflare tunnels that you can setup with your own domains (or using ephemeral domains).

Under the hood, woltspace is powered by tmux, which means that sessions persist and can easily be resumed and accessed from anywhere. I personally drive woltspace mainly from the telegram integration, which gives me access to my wolts and CLI literally from anywhere. This means I can chat with Claude code CLI from anywhere, spawn new sessions, all running on my own infra. It’s also all in a docker container so you don’t have to worry about approving every single command.

95% of woltspace was built from within woltspace, and it’s becoming my prefered way of building.

Another feature I really like: the “inter wolt communication layer”, IWCL, allows wolts to chat with each other, making things like having fable orchestrate a gpt 5.6 something that works out the gate.

Woltspace is meant to be used by power users (you can bring your own tmux config and use the TUI CLI) or by beginners. The default split pane makes SEEING what you’re working on really intuitive. Each wolt can host its own website where they can render arbitrary html making planning new features much more intuitive.

It’s all open source, and I’m constantly adding features to it. Woltspace is mostly self documenting, all of the features are also skills the wolts have access to. I'm also improving the documentation surrounding the project as we speak.

Looking for some feedback and users to try it out. You can one line install it with

curl -fsSL https://woltspace.com/install.sh | bash

Project page: www.woltspace.com GitHub: https://github.com/jerpint/woltspace

https://thenimzo.com

A probability grid of chain-of-thought, read through Boyd's OODA loop lens [0]

[0] https://adamsohn.com/reasoning-grid/

It’s an attempt to make chess a bit more, you know real:) Like countries buy armies, chess kings can buy figures. Also it’s easy to bring these new rules into offline games.

It’s quite early stage yet, but you can give it whirl at https://chesspoly.com/

https://www.bobek.cz/buse/

We're working on our WASM API this month, as AI-native startup law firms are looking to use it on their web platforms: https://tritium.legal/wasm

It’s as simple as it sounds: 100,000 chess puzzles, all offline, rated (just like chess.com or lichess puzzle modes)

A big thing I added that makes mine unique is the play it out” mode that allows you to finish the game with a chess engine of equal difficulty

You get 20 free puzzles per day, or a $5 lifetime purchase for unlimited puzzles and features: https://justchesspuzzles.com

==> An FPS game editor, using photos as 1st imput. ==> It delivers a realistic FPS game. immersive-visit-game as we like to call it. ==> The FPS-Runtime is the lightest FPS existing today. It works on any web device, even Smartphones.

==> https://free-visit.net/

I initially made it as a lightweight, keyboard-centric alternative to dbeaver/pgadmin, and it now covers 95%+ of the database-related tasks I need to do at my job.

It's for agent + human devboxes, for chatting with coding agents from the web, or automating them with an API. Thing like Claude Code web, but any agent and you directly control the VM, too.

We're working to make amika.dev work on any computer, homelab, or K8S cluster. For tech folks, I describe it kinda like if Tailscale and Firecracker had a baby.

AI wise I’ve been refining my workout app for a few months and it’s ~90% there - I get good workouts now but I’m constantly tweaking / adding features. My kanban / planning tool has also become very useable with the latest updates. Next up I’m working more on a guitar practice app and a baby life app.

A daily puzzle game called Dozenal where you solve each puzzle board by creating chains totalling the number 12. My friend and I came up with the idea over a decade a go, and have finally started bringing it to life in the past couple of months.

I built a simple wish list app that anyone can create a wish list and share without the need to create an account. Great for birthdays, evergreen lists, Christmas, etc.

whichwishlist.com/

https://github.com/hummingme/kahuna

And some yak shaving in the form of selective zoom, where only the board would zoom in but the clues around the board would still remain visible.

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

Aside from this:

- I asked codex to use my mobile app and web page for the flashcard UX, and make me one using qt + qml so I could run it on the remarkable 2, super happy with the initial results. This will be released as a reference for others, as the eco-system is too clunky today to offer it the non-technical users of remarkable devices.

- I learnt about my set-up box, and got assistance in making my first app, so I can post and image from my iphone to it via shortcuts. Currently, it only accepts one photo, but it is cool throwing it up on the tv. This also let me learn a little more about "ios Shortcuts" and cherri, a golang cli, that makes it a little easier to make shortcuts.

- Using nurb, to 3d print things, currently working thru printing a stand, so I can mount an iphone and record doing things on the remarkable. Its been really fun testing with little physical prototypes of small parts to then roll into the stand.

#Reference

- https://nurb.dev/

- https://x.com/freshteapot/status/2085692070337888698

- https://learnalist.net/features/mobile-learnalist-v1.html

[0] https://parallelthoughts.xyz/2026/08/learning-linux-io-part-...

https://github.com/hill/lazyslurm

https://m.youtube.com/@MartinCapodici

Sanctum already has very capable traffic analysis protections in place in the form of shroud, but being able to build mixnets will make it even more valuable.

But it’s been vacation time so it’s been slow progress as time away from the internet is equally valuable.

[0] https://sanctorum.se

https://orcabot.com/benchmarks

https://ctrailtime.com

It uses webtransport instead of websockets for the networking transport so the games feel a lot better than normal web based multiplayer games. I'm surprised more people aren't using webtransport given it's supported now by all major browsers.

https://dbcooper.amal.sh -> Database client

It's a darkroom toy/simulator for photogs running in the browser on WebGPU. It's half film sim, half creative chaos and each run is different. Still pretty early.

https://github.com/conductor-oss/conductor-agents/tree/main/...

Open for collaboration, still in early dev.

One week in.

https://shikigami.dev

BETA - means, production ready, but not still extending and experimenting with features - I keep working on it, and collecting feedback.

It creates sound from math expressions which were inspired by the Desmos graphing calculator.

The sounds are mainly of the FM/DX7 taste.

i can't decide whether to show my progress on video by hiding or showing the expressions LLM(s) and myself "discovered".

It sometimes sounds extremely musical and sometimes very dirty and experimental, what's normal for frequency modulation.

Please help me decide: show all and open source or continue working on it and pitch it to some big names. ;-) I have the feeling it has strong potential for prototyping, as well as taking the role of a keyboard engine. It is completely viable to manipulation via AI because of its concept.

It runs nicely on an M4 Mac mini with 256 voices of polyphony and has a very high level of expressivity mainly via half-pedaling (sustain pedal).

Velocity, 8 macro knobs, no filters, no fx, ADSR envelope. A web interface and additionally CLI.

currently building a backend for recurring invoices, a public API, and an MCP server. recently hit 1k stars on GitHub =)

https://github.com/VladSez/easy-invoice-pdf

features:

- no sign-up required and no ads

- live PDF preview & instant download

- save seller & buyer profiles

- flexible tax support (VAT, GST, sales tax, etc.)

- fully customizable invoice templates

- 120+ currencies and 10 languages supported

- and much more

Idk who it helps, but it's been a fun journey!!

It started as a tool to help me figure out if I need to protect my plants or water them down here in New Orleans since we don't really have freezing season, but also have super hot days or rain issues.

A better way to track real-time pricing of DRAM and HBM pricing in the market specific to equipment type, manufacturer, and other metrics. Feedback welcome to improve and see if there is a market for something more in-depth.

https://store.steampowered.com/app/4760970/Quilt/

Seems everyone is building an inference platform lately, but this one is mine! And I'm enjoying it...!

Surviving Dreams - long horizon code agents that work while you sleep. we're unlocking the next 12 hours of gdp. www.survivingdreams.com

* Java: https://github.com/la3lma/rmatch

* Rust: https://github.com/la3lma/rustmatch

https://imgur.com/a/kP1aKIU

Oil on canvas, about 28 x 22 in.

https://github.com/wmedrano/consult-jj

https://parakeet.narcotic.sh

The aim is for it to be a high-performance implementation. Can currently transcribe 1 hour of audio in 20 seconds on an M5 Mac.

https://ben3d.ca/blog/gaussian-splatting-for-threejs

This PR was merged yesterday morning so the August ThreeJS release will have this new feature.

20 points | 6 days ago | 68 comments

https://github.com/patrickjh/ssa

It's just me, building my own tools and self-hosting them. Atoll is a project management project. Nothing fancy, not over-engineered: - Go - SQLite - HTMX (server side rendered, no SPA)

Archipel will count different other projects (Atoll, Balise, Passe, Sillage)

Also building a Golang middleware to record analytics (saved into a local duckdb)

https://www.inertiagraphics.com

I've been working on this guy too https://github.com/Agustin-Delgado/repath. It's a modern circuit sim with a lot of bugs and things to be tested.

Basically a 2d rts, fully orthogonal view, plays in space with spaceship combat.

You start with a deployable base, kinda like the old C&C, which you can place around a minable planet. Than from this you can place further structures arround that planet including the typicals, mining (2 types) of resources, researching stuff, and building ships.

The 2 things i focus the most on in this game on are

1. Responsiveness. Im a strong fan of starcraft 2 (and brood war) and have spend tons of time playing sc2. I love this super responsive controles and its the only thing i will settle for in terms of controles

2. I love the game starsector (yes no rts) for the way its ships are designed. You have a base hull that has some stats like hp / speed / etc - than this thing has basically mountpoints where you can fit weapons into. I always loved this system. So what i build is a game where you can (outside of battle) define your desired ship blueprints combined of a hull, weapons and "inbuilds" (as in upgrades). You can than just build those ships ingame.

So ye made quite progress so far , not sure tho what will be the first mode i focus on once i get a playable (as in demo) state.

Btw using godot engine as base, but some logic is running as c++ gd extensions (rts is heavy calcs , gdscript is just not fast enaugh (or im just not a gamdev ¯\_(ツ)_/¯)

Here a screenshot of the ship blueprint editor for those who are curious - https://i.postimg.cc/bq5JB9J7/editorexample.jpg

I have fallen in love with the idea the more I spoke to potential customers. The initial feedback has given me confidence to commit to this full-time.

[0] - https://github.com/con-dog

Neural networks | Game engines | Games | LLM Benchmarks | Graphics

https://aven.raine.dev/

It upgrades your GitHub pull request review experience with a guided walkthrough of the PR optimized for reading.

https://lumirank.ai/

Most inventions are just better versions of things that already exist - I'm building the Google Workspace for clubs.

P.S. Credit to adityaathalye for the change of phrasing for these posts to add "what are you curious about?"

https://www.GetSetReply.com

I help small businesses with review management. Getting more reviews, replying to reviews, and some other related features.

Right now I'm trying to figure out how to get users and make sales. I'd love advice from someone in the community that is willing to share their experience and wisdom!

Similarly, if there are folks here from outside of the US with some ideas/feedback on getting into other markets, I'm interested to hear about that too.

The other project I've been working on is:

https://ALovelyQuestion.com

We plan proposals within your budget

- nichromecast - TUI/CLI Chromecast sender with for local files and YouTube URLs - https://github.com/evidlo/nichromecast

- syncthingtui - TUI for administering Syncthing on headless machines - https://github.com/Evidlo/syncthingtui

- Need for Madness Web - WebGL port of an old Java racing/derby game - https://radicalarchive.github.io/nfm/

- MdInvetory - Markdown-based personal inventory editor - https://github.com/evidlo/mdinventory

It was clear to me that a marketing harness was needed around the LLMs for this purpose, and so Feral was born.

https://feralhq.com

I know there are lots of options in this space, but I wanted to experiment with a new approach: a compositor overlay. During transitions (like scrolling on focus, moving a window, etc.) an overlay pops up and uses _screenshots_ of windows for animating while the real windows move below. Once in place, the cover dissolves out. It's not perfect, but this makes it _feel_ much closer to native.

https://alethean.org

https://guesstimate.offclock.dev/

What it is: Self-hosted email marketing software

Been doing so since 2024 (pre AI coding era).

In particular, I’m exploring what the infrastructure should look like when agents are the primary users: deployment, databases, domains, secrets, observability, and lifecycle management.

The goal is that everybody and their pet can deploy an app.

These units are called saasies, and the project is Saasie.

i'm using react on the front, pretty interesting how it manages states in the frontend and how to come up with new strategies to not trigger so manny re-renders of the UI, and on the back i use fastapi with postgresql and oauth2

https://zine-fold.com

It's a bookmarker tool.

https://miu.dev/

Google Maps is great for route planning and looking up things you already know about, but it's pretty useless for discovery. Sometimes you just want to know what places are actually worth going to as a tourist or backpacker.

It's the kind of information you'd traditionally get from guide books, but in a format that IMO makes a lot more sense - a map. Right now the scores and content are seeded by an AI, but the idea would be for these to eventually be user-derived.

It's still pretty early and I have a WIP native app which makes it a lot nicer to interact with on mobile, but it would be awesome to get people trying it out already. It's free to use, with nothing paywalled or anything like that. I'd only think about some kind of monetization if it actually gets some traction. Would love any feedback!

- Ongoing work on an airline announcement engine that works with flight simulators

https://github.com/fearlessfrog/MSFS_Universal_Announcer

- A multiplayer board game for Discourse forum users that is not the popular Risk (tm).

https://github.com/fearlessfrog/discourse-not-risk

Both have a fair bit of traction, but is often the case, keen to do something new this month.

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

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

https://brynet.ca/wallofpizza.html

(Native SegWit): bc1qwe6zv0ezq4gzlea6tw45qhsn5kckheljn0krvt

https://www.tirreno.com

Password is vaultearly644988 if you want to check it out.

The companion app, a widget-first RSS headline viewer called Just The Headlines is just about done too. Site is online if you want to see screenshots: https://justtheheadlines.app

I'm in the (required, sigh) closed test phase of Google Play Store approval. Drop me a line on X (https://x.com/JJordan) if you would like to join the test for that.

Feedback is more than welcome.

https://june.kim/human-signal

https://github.com/bikeshaving/termdom

Since I could not find anything out there, I am scratching my own itch.

The basic idea is that instead of trying to solve the general case in robotics (ie, the humanoid companies - multiple tasks, multiple environments, generalization, etc) which needs billions of capital, can you efficiently deploy current tech to robustly do one task in one environment for cheap.

I'd hoped for a more meaningful update from when I first mentioned Vestiges last month (https://news.ycombinator.com/item?id=48884984). But I've often felt discouraged and haven't worked as much as I'd intended.

As was recommended by guiambros last month, I started the process of setting up Vestiges on Steam, but that's still in progress (currently, my identity is being verified). I also set-up at micro.blog (https://ksaun.micro.blog/) and (https://mastodon.social/@ksaun), but haven't posted anything yet.

I bought a Linux laptop for this project (I was working on a 2020 Surface Book 3). (I had used Unix in the 1990s, but not much since then. The video game industry being so Windows-centric, I'd stuck with that OS throughout my career.) So recently I spent a few days enjoying (not sarcastically!) setting up my new computer and work environment. In doing so, I also took improved some aspects of my development process.

Limited meaningful work on the game itself. From a technical perspective, I could release the demo now, but I'm dissatisfied with the content (specifically the writing). Not that it needs to be amazing just yet, but I want it at least less embarrassing. As I've worked with some of the best game writers in the industry (in my opinion; people like Chris Avellone, George Ziets, Neal Hallford, Brian Mitsoda), I'm accustomed to quality that exceeds my personal ability. And this writing work requires greater focus than I can usually muster, so I've been procrastinating, polishing other things that were already sufficient to ship.

Since last time, I've finished most work on tutorial features and content as well as the other implementations I wanted for the demo. For the modes that are ready, I added full support for keyboard-only play (which was a more substantial effort than I'd anticipated, taking close to two days (very part-time for me, but Claude was fairly busy)). I also now have an MCP server implemented so that Claude can playtest as a player would, but I've only just started to make use of it. (And some progress on the aforementioned writing, just not much.)

https://github.com/nordstjernen-web/northstar-browser

Still on plex, next step is Jellyfin.

https://github.com/gofabrik/fabrik

I’ve been waiting for a spine surgery and to do something with my time I started experimenting with an idea I had. It completely pulled me in, and helps me to distract myself.

It is work in progress, lacks of documentation, I am not even sure I will release it.

A new kind of GPU library written in rust with backends for CUDA, DX12, Vulkan, and Metal (tenstorrent and wgpu are planned) and bindings for rust-dynamic, python, c++, c, and dotnet (Java and Fortran are planned).

Uses the slang shader language exclusively. All submissions are expressed as graphs (like cuda graphs), are retained automatically (sometimes partially with a graph partition algorithm), and automatic synchronization of GPU resources. No runtime dependencies (slang is vendored) and new calling convention for shaders using a virtual entry point that allows resources to appear as arguments to the shader 'main'. Includes automatic VRAM and resource recycling for device resources.

Shader coroutines, rust shader authoring, and automatic kernel fusion are planned.

Supports both GPGPU and graphics.

Made it because cross backend GPU libraries usually either target lowest common denominator or are specialized for either compute or graphics or ML. In my experience GPU programs and frameworks are written to target a different kind of machine than a tape machine, but nobody outside of tenstorrent have bothered to describe that machine. So I defined a new kind of abstract machine for cooperative resource-oriented computation called a Fondaco machine for which goldy is the reference implementation.

Indexing multiple captured video streams with awarded action points and adding athlete/referee positions overlay. Stretch goal -- controlling PTZ camera for predictive capture of the high intensity actions.

Nothing too interesting though.

I have more interesting projects, but these have to come after I focus on more pressing reallife requirements; on my next todo list, though, I want to extend the code I use to compile from source. I track almost 4000 programs already and can compile most of these (for some reason GCC 16.2.0 does not want to compile today); I want to extend this, finishing an automatic build of the linux kernel and full bootstrap into a new system while also adding more language bindings, such as lua. And also allow for this to be compilable via a web-interface.)

[1]https://www.makonea.com/en-US

https://wafertown.com // the first LLMORPG, you write a prompt and your character "lives" through a simulation of life using it as a guide, interacts with others, etc. sends you a summary of what it did and allows you to steer it for next day. think of it as a small tamagotchi but with hundreds (hopefully thousands!) of other players

Too many times I have been burned by applying to scam listings or people who are just to self-promote and use people who want a job as a marketing channel (looking at you BetterStack, fu in particular).

I want people to be able to discuss and flag companies which are lying or just a waste of time, yet HN refuses to do anything about it and doesn’t allow threads as discussions and removes comments.

Hit me up if you want on the beta testers lists, already got a couple of people.

rocket.dev22@gmail.com

A cheap rowing counter. Competitive rowers use a training device that counts their strokes per minute. I figured out that the major parts are really cheap, even as individual purchases, so I wanted to build a budget version. So far it counts strokes fairly accurately and I've just completed initial tests of the display.

Drone experiment. I'm building a image recognition drone from scratch. It's based on a H743 Slim V4, with an RPI5 and a OAK-D Lite. I'm currently trying to figure out why the back left rotor is producing way too little thrust.

Like everyone else, I'm also working on an agent harness. tl;dr I don't trust any agent to not be dumb, but the agents seem to have some success recognizing when the work of an other agent is dumb. In early tests, the back and forth seems to provide more stable and better results.

https://thedividendetf.com/

..but I get to take the common stuff from each and put it into an open-source Godot framework so as to not feel totally useless :')

https://github.com/InvadingOctopus/comedot

and all of this is making me want for a better programming language designed from the ground up for games, with no need to care about hardware, so I've been brainstorming and rubber-duckying about that as well.