I am open to additional feedback. If you have points of comparison please let me know in the comments!

Unlike similar apps such as Focus Friend or Forest, which use active timers to police screen time, my app is an inversion that works like an idle game; All screen time is tracked all day, (with double the punishments at night), and upon check-in, you get feedback on your device usage.

https://automatisolutions.com/products/phreepet/

8/15 on SWE-bench Verified vs Claude Code's 5/15, ~$0.06/instance vs ~$0.12. Small sample, single repo, lots of caveats. But the direction feels right. Event-sourced reducer, no framework deps beyond the Anthropic SDK.

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

https://lobu.ai

When booking flights, I use sites like Kiwi and Skyscanner that let you do flexible searches - multiple destinations, custom connections, creative routes, etc. But rail search feels oddly constrained. All the UK train operators offer basically the same experience, and surface the exact same routes. I always suspected there were better or just different options that weren’t being shown. Where is the "Skyscanner for trains"?

After digging through the national rail data feeds, I decided to have a go at building my own route planner that runs completely offline in the browser. This gave me the freedom to implement more complex filters, search to/from multiple stations, and do it without a persistent network connection.

Now I'm finding routes that aren't offered by the standard train operators, connecting at different stations, and finding it's often easier to travel to different stations (some I'd never heard of) that get me closer and faster to where I actually want to go!

It's still a little rough and I'd like to add more features such as fares, VSTP data, and direct-links to book tickets, but wanted to share early and get some initial feedback before investing more time into it. So, thanks in advance - let me know what you think.

I also make small games with Godot.

"The irony of Backstage is that it was created to prevent teams from having to reinvent the wheel every time, building and maintaining their own developer portal. But that's exactly what everyone does with Backstage."

We wanted something you configure,deploy,update. thats it.

service catalog, GitHub crawler, K8s entity discovery via k8s-push-agent, Forge + molds (scaffolding/workflows, like Backstage templates), governance, scorecards, cloud provider resources, license management, event based notifications, team-context aware, API keys with scope auth alongside session RBAC. CLI and Terraform provider too.

We're aiming to release Beta end of April.

https://tiledwords.com

After winning the Playlin Player's Choice award I've noticed an uptick in players as well as some people sharing videos on YouTube which has been fun. I've got a few thousand people playing every day.

I just launched user accounts today so user's can now track their progress across devices and share their stats with each other. This ended up being a bigger chunk of work than I expected but I'm really pleased with how it turned out. (Though I launched it 15 minutes ago so I'm holding my breath for bug reports)

I'm fine-tuning my internal puzzle-building now with the goal of letting people use them to make and share their own puzzles soon!

It's an iOS app that applies various generative art effects to your photos, letting you turn your photos into creative animated works of art. It's fully offline, no AI, no subscriptions, no ads, etc.

I'm really proud of it and if you've been in the generative art space for a while you'll instantly recognise many of the techniques I use (circle packing, line walkers, mosaic grid patterns, marching squares, voronoi tessellation, glitch art, string art, perlin flow fields, etc.) pretty much directly inspired by various Coding Train videos.

Direct download link on the App Store is https://apps.apple.com/us/app/photogenesis-photo-art/id67597... if you want to try it out.

* Coming to Android soon too.

I initially was using SSE to push events down to the front end during long scans but decided to switch over to plain old HTTP polling for better reliability across different browsers (and versions of different browsers).

Here are the areas of analysis:

    - accessibility
      -- check for images with missing alt text
      -- check for various form controls missing labels
      -- headings not following (h1->h2->h3...)
      -- missing lang attribute on <html>
    - content
      -- check for forbidden words and phrases
      -- check for required words and phrases
    - performance
      -- evaluate time to load page
      -- check for excessive inline JS
      -- check for inline styles
    - security
      -- check for SSL certificate expiring soon
      -- check for security HTTP headers
      -- check whether Server HTTP header is too revealing
    - seo
      -- check for missing title in head section
      -- check for missing meta description
      -- check for multiple H1 headings
    - site integrity
      -- check for broken links
      -- check for use of deprecated tags
      -- check for insecure http link
    - spell check
      -- check for possibly misspelled words

Going for a 100% self-service model. No corporate sales cycles, no slide decks, no meetings.

Targeting a June launch.

You can read more about it over at the site, but it allows you to construct and validate arguments in a graphical form, and it has truth/proof propagation so you can see whether a conclusion is currently considered valid or contested. You can create counterpoints where you think the argument breaks down, and strengthen arguments from there. Some upcoming plans are to allow users to validate arguments for themselves, like mark which parts they understand and agree with so they can collapse that part of the graph, and to add more mcp capability so that LLM can help you construct and validate new arguments.

I'm leaning heavily on simulation, economics, towns with real economies, and interweaving progression systems. It's a custom engine. I finally have the foundation built, it's multiplayer ready, and it currently loads in under 200MB. The idea is to be hyper efficient to simulate multiple towns that grow by themselves and you can trade and interact with.

https://www.youtube.com/watch?v=BeZ3O6F5FXU

It's a free-time project, but I will happily take investment and make it my full-time project. :) I have a game design-doc that I have built out, and I personally like it a lot. I believe in it's potential.

https://playruly.com

My goal is to make a simple yet interesting procedural and replayable puzzle. It has a couple of weekly variations: on Saturdays you need to break a rule to score max points, and on Mondays there's an added memory aspect which brings variety to the game.

It's mostly vibe-coded which lets me focus on game design and testing. The next step is better onboarding/tutorial and more intuitive UI.

The use case is kind of neat. RAID is great and can mostly solve these problems, but people don't have SATA hardware that can handle the workload well, plus they aren't ready to manage an array like that, and they don't like having to use specific sized drives, etc. Another major issue with those setups is you need to be careful because an IO error that you don't recover from will be very difficult or impossible to recover from because of the layers of LUKS combined with LVM.

With MergerFS you just use regular file systems that are separate, but they get combined into a single mount point. That means each disk can just be a different LUKS encrypted drive and if you need to recover data it's isolated to that one disk and much more manageable. You can also take any disk and plug it into another machine as needed and grow or shrink the storage pool as needed.

MergerFS has options and settings to help you determine how files are spread across the drives, such as least space used or which disk has the most of that directory path already.

My app (Chimera) automates the unlocking of the disks, mounting and some data migration if you want to remove a disk from the pool. I plan to add some rclone features to help provide easier backup options to places like Backblaze, AWS, or a remote server in general.

So far so good and I was surprised at how well Opus had been handling Gtk and pkexec.

Let me know if you guys are interested I am close to pushing some RPMs and DEBs, in addition to the standard Python stuff.

Yupcha AI Interviewer, handles the screening, video interviewing with conversational agents.

Check it out https://yupcha.com

Working on a oss video dubbing, cloning and design studio

Check out https://github.com/debpalash/OmniVoice-Studio

Suggestions are welcome.

I wanted to make it easier to quickly see/study trending articles on Wikipedia because they tend to make good topics to know before going to trivia night.

I've had the domain for awhile, but just made the app today on a whim.

I use Wikimedia's api to get the trending articles, curate them a bit, add some annotations to provide some context, then push to deploy the static site.

Imagine mixing Magic: The Gathering, StarCraft and Civilization’s hex grid combat.

There’s multiplayer but I haven’t put the server anywhere yet.

Check out the introduction here:

https://github.com/williamcotton/space-trader/blob/main/docs...

Clone the repo:

  npm install
  npm run dev

This project brings in a lot of AI support. It's made a massive difference. The original project took two years to finish (actually four, but we did a "back to the ol' drawing board reset).

It looks like this may only take a couple more months. I've been working on it for two months, already, and have gotten a significant amount done. The things that will slow it down, will be the usual sand in the gears: team communication overhead. Could stretch things out, quite a bit.

Model output volumes mean that code review only as a final check before merge is way too late, and far too burdensome. Using AI to review AI-generated code is a band-aid, but not a cure.

That's why I built Caliper (http://getcaliper.dev). It's a system that institutes multiple layers of code quality checks throughout the dev cycle. The lightest-weight checks get executed after every agent turn, and then increasingly more complex checks get run pre-commit and pre-merge.

Early users love it, and the data demonstrates the need - 40% of agent turns produce code that violates a project's own conventions (as defined in CLAUDE.md). Caliper catches those violations immediately and gets the model to make corrections before small issues become costly to unwind.

Still very early, and all feedback is welcome! http://getcaliper.dev

This week I added TTS support, which needed multiple inference pipelines, it was not easy to find models for 50 languages!

At this point, it mostly works as a crude implementation of Google translate+Google lens, but 100% offline and 100% Google-free

Its like a microservices architecture with NATS JetStream coordinating stuff. I want to keep the worker core as clean as possible, just managing open sockets, threads and continuation.

Document querying is something I am interested in also. This system allows me to pin a document to a socket as a subagent, which is then called upon.

I have hit alot of slip ups along the way, such as infinite loops trying to call OpenAI API, etc ...

Example usage: 10 documents on warm sockets on GPT 5.4 nano. Then the main thread can call out to those other sockets to query the documents in parallel. It allows alot of possibilities : cheaper models for cheaper tasks, input caching and lower latency.

There is also a frontend

Alot of information is in here, just thoughts, designs etc: https://github.com/SamSam12121212/ExplorerPRO/tree/main/docs

I want to show how I liberate poorly aligned, pixelated PDF image scans of century-old Latin textbooks from the Internet Archive and transform them into glorious Org mode documents while preserving important typographic details, nicely formatted tables, and some semantic document metadata. I also want to demonstrate how I use a high-performance XML database engine to quickly perform Latin-to-English lookups against an XML-TEI formatted edition of the 19th century Lewis & Short dictionary, and using a RESTXQ endpoint and some XQuery code to dynamically reformat the entries into Org-mode for display in a pop-up buffer.

I intend demonstrate how I built a transcription pipeline in Emacs Lisp using tools such as yt-dlp and patreon-dl to grab Latin-language audio content from the Internet, transcode the audio with ffmpeg, do Voice Activity Detection and chunking in Python with Silero, load the chunks into Gemini's context window, and send it off for transcription and macronization, gather forced-alignment data using local a local wav2vec2-latin model, and finally add word-level linguistic analysis (POS, morphology, lemmas) using a local Stanza model trained on the Classical corpus.

This all gets saved to an an XML file which is loaded into BaseX along with some metadata. I'll then demonstrate some Emacs Lisp code which pulls it into an Org-mode based transcription buffer and minor-mode for reading and study, where I can play audio of any given Latin word, sentence, or paragraph, thanks to the forced-alignment and linguistic analysis data being stored in hidden text properties when the data was fetched from the database.

Lastly, I'd like to explore how to leverage these tools to automatically create flash cards with audio cues in Org mode using the anki-editor Emacs minor mode for sentence mining.

I had an insight the other day, that as I fix the n least (and most, it's a palindrome!) significant decimal digits, I also fix the remainder from division in 5^n. Let's call it R. Since I also fix by that point a bunch of least (and most) significant bits, I can subtract how much they contribute mod 5^n from R, to get the remainder from division in 5^n of the still unknown bit. The thing is, maybe it's not possible to get this specific remainder with the unknown bits, because they're too few.

So, I can prepare in advance a table of size 5^n (for one or more ns) which tells me how many bits from the middle of the palindrome I need, to get a remainder of <index mod 5^n>.

Then when I get to the aforementioned situation, all I need to do is to compare the number in the table to number of unknown bits. If the number in the table is bigger, I can prune the entire subtree.

From a little bit of testing, this seems to work, and it seems to complement my current lookup tables and not prune the same branches. It won't make a huge difference, but every little bit helps.

The important thing, though, is that I'm just happy there are still algorithmic improvements! For a long while I've been only doing engineering improvements such as more efficient tables and porting to CUDA, but since the problem is exponential, real breakthroughs have to come from a better algorithm, and I almost gave up on finding one.

[0] https://ashdnazg.github.io/articles/22/Finding-Really-Big-Pa...

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

I noticed every competitor in this space was a chatbot with only the last ~10-15 messages stuffed into context. They forgot things, made up dice rolls and rules, and was generally not what I was looking for. So far TableForge has been working well for my friend groups and some random folks from Reddit/organic search. Solo TTRPGers seem to like it too.

It's still in early stages but fully playable. I don't feel comfortable charging anything for yet until I know people enjoy it. If you like it enough to hit the free tier limit, send me some feedback in the webapp and I'll gladly extend your free trial. If you hate it, please also let me know!

[0] https://tableforge.gg/

https://greenmtnboy.github.io/sf_tree_reporting

Posted in last thread when it was SF only: https://news.ycombinator.com/item?id=47303111#47304199

I use it when I have candidate libraries to solve a problem, or I just want to find out how things work. Most recently I pointed it at fzf and was able to pull the insensitive SIMD matching it uses and speed my own projects up.

I can’t find it right now, but there was a post about how ripgrep worked from a someone who walked through the code finding interesting patterns and doing a write up on it. With this I get it over any codebase I find interesting, or can even compare them.

By tuning the agent, it is possible to create trading strategies [1] and reverse engineer websites in order to create optimized JSON APIs using the websites internal private APIs. [2]

I'm having the hardest time communicating what is happening so next I'm going to try to explain it using data visualizations so people can visualize it in action.

[0] https://github.com/adam-s/agent-tuning

[1] https://github.com/adam-s/alphadidactic

[2] https://github.com/adam-s/intercept?tab=readme-ov-file#how-i...

PSA PS. Don't post generated/AI-edited comments. HN is for conversation between humans https://news.ycomtem?id=47340079

https://virissimo.info/build-your-own-alu/

LMK what you think.

Delinking is the art of stripping program for parts, essentially. The tricky part is recovering and resynthesizing relocation spots through analysis. It is a punishingly hard technique to get right because it requires exacting precision to pull off, as mistakes will corrupt the resulting object files in ways that can be difficult to detect and grueling to debug. Still, I've managed to make it work on multiple architectures and object file formats; a user community built up through word of mouth and it's now actively used in several Windows video game decompilation projects.

Recently I've experimented with Copilot and GPT-5.3 to implement support for multiple major features, like OMF object file format and DWARF debugging symbols generation. The results have been very promising, to the point where I can delegate the brunt of the work to it and stick to architecture design and code review. I've previously learned the hard way that the only way to keep this extension from imploding on itself was with an exhaustive regression test suite and it appears to guardrail the AI very effectively.

Given that I work alone on this in my spare time, I have a finite amount of endurance and context and I was reaching the limits of what I could manage on my own. There's only so much esoterica about ISAs/object file formats/toolchains/platforms that can fit at once in one brain and some features (debugging symbols generation) were simply out of reach. Now, it seems that I can finally avoid burning out on this project, albeit at a fairly high rate of premium requests consumption.

Interestingly enough, I've also experimented with local AI (mostly oss-gpt-20b) and it suffers from complete neural collapse when trying to work on this, probably because it's a genuinely difficult topic even for humans.

[1] https://github.com/boricj/ghidra-delinker-extension

An important feature for me was improving the recipe discovery experience, you can build a cookbook from chefs you follow on socials (youtube for now), or import from any source (Web, or take pic of cookbook etc) - it then has tight / easy integration into recipe lists.

Utilising GenAI to auto extract recipes, manage conversions, merge/categorise shopping lists etc - as-well as the actual recommendations engine.

If anyone is interested in beta testing / wants to have a chat I'll look out for replies, or message mealplannr@tomyeoman.dev

https://www.roastrack.app/

https://github.com/NetwindHQ/gha-outrunner - github actions local, ephemeral runner which runs jobs in docker container, tart vm org kvm (depending on the host/guest)

First time doing this sort of thing with agents. So far it seems ok?

If it works out it will really help us scale and improve a legacy application that so many depend on at the moment. Wish me luck!

I just published a fun interactive 3D demo of SPDC, one of the most common and accessible ways to create entangled pairs of photons. I'm hoping to publish a series of articles on other cool learnings about doing quantum photonics in the lab.

https://paulg.info/2026/04/10/spdc/

Live Kaiwa (https://livekaiwa.com/) — A real-time Japanese conversation assistant. It listens, transcribes, translates, and suggests responses so you can follow along in conversations you'd otherwise get lost in. I built it because I live in Japan and needed something for the situations where missing a nuance actually matters — PTA meetings, bank appointments, neighborhood councils.

3 days ago, 220 comments: https://news.ycombinator.com/item?id=47700460

5 days ago, 51 comments: https://news.ycombinator.com/item?id=47679021

8 days ago, 21 comments: https://news.ycombinator.com/item?id=47639039

11 days ago, 22 comments: https://news.ycombinator.com/item?id=47600204

It allows you to get a wake up call from someone friendly, somewhere out there in the world.

It's got a handful of regular users and it's mostly me making the calls, but it's great fun to wake people up!

No phone number required - these are VoIP calls via the app.

Built it because I think it's cool.

Unlike those apps it has full support for design tokens and (so far) flexbox layouts. It can also export directly to HTML, rather than a fake preview mode. I’m also working on full code-backed components, so you can go between code and design very easily.

As a designer, I’ve been frustrated for years by the gap between design and code, and despite all the new AI features, Figma still hasn’t got any further in years - design tokens need a 3rd party plugin and responsive designs are a pain in the bum. So I decided to build something that has the ease of Figma while being much closer to live code.

I’ve got to the point where I’m designing the app in itself, tokens are working, html export is working and nearly ready for first betas.

But at my current knowledge and practical work, its like giving a chimpanzee a nuclear reactor schematic. But it's a passion project idea of mine, I really want it to become real one day. Personally, I feel like something much better can be made than current solutions.

https://ewams.net/?date=2026/03/29&view=Qwen35_Performance_w...

It's a free USCIS form-filling web-app(no Adobe required). USCIS forms still use XFA PDFs, which don’t let you edit in most browsers. Even with Adobe, fields break, and getting the signature is hard.

So I converted the PDF form into modern, browser-friendly web forms - and kept every field 1:1 with the original. You fill the form, submit it, and get the official USCIS PDF filled.

I found out SimpleCitizen(YC S16) offers a DIY plan for $529 [2]

So, a free (and local-only) version might be a good alternative

[1] https://fillvisa.com/demo

[2] https://www.simplecitizen.com/pricing/

https://gist.github.com/paulshomo/69cf99e3185fa7ad0f50fc0e38...

https://github.com/jank-lang/jank

It's a native Clojure dialect which is also a C++ dialect, including a JIT compiler and nREPL server. I'm currently building out a custom IR so I can do optimization passes at the level of Clojure semantics, since LLVM will not be able to do them at the LLVM IR level.

We have over 60 shows now, rented a studio, and are in talks to security a site for our tower. I'm building out an online store but really need to focus on fundraising.

https://asnlabels.com

It's free, no sign up or ads - feedback welcome :)

It's a tool that use QDrant, a vectorial db, to embedding the texts chunks: LLM api is questioned to generate the Q&A pairs from a chunked texts.

Each chunk is then embedded and stored in the vectorial db to facilitate the Q&A generation, thanks to better context informations.

This tool helping people to study everything thanks to even Spaced Repetition algorithm.

I have a terraform setup right now but it’s super awkward and very slow. The goal is to be able to define settings using PKL which looks super interesting. Wanted to try it out for a while now.

I've worked with data my entire career. We need to alt tab so much. What if we put it all on a canvas? Thats what I'm building with Kavla!

Right now working on a CLI that connects a user's local machine to a canvas via websockets. It's open source here: https://github.com/aleda145/kavla-cli

Next steps I want to do more stuff with agents. I have a feeling that the canvas is an awesome interace to see agents working.

Built with tldraw, duckdb and cloudflare

I'm not sure if I'll every productize it in any way, but I could see a world where it's used by people prepping for the bar, med boards, various continuing education stuff. Right now it's just a fun platform to build on as I explore the current wave of technologies. Building a framework for evaluating different LLMs for best price/accuracy. Adding a RAG pipeline so wrong answers can point back to source material for further review, etc.

I'm looking at moving from backend engineering to a more MLE or agent pipeline role, so this is giving me something more than school projects to build on. While also helping me do better at school.

[1] https://studyengine.app/

https://housecat.com/docs/editorial/why-housecat

The ideas I’m thinking about is: what’s old is new.

We’re seeing a massive influx of people writing software and administering servers for the first time ever. But so many people are jumping (or being pushed) into the deep end without basic training.

Lots of opportunities for us older admin folks to build, teach and help all the new folks.

A SSO application in rust(not public)

A DNS for a dream project of mine which is a hosting provider company like digital ocean but in Scandinavia(not public).

A code hosting site for said hosting company called bofink(not public)

Ansible playbooks for applying database patches that can resume and create schemas etc, based on an internal tool from a former job. This is public and available on my github if anyone wants to look at it not linking it because there are way cooler projects here.

The app is built in React Native (almost entirely with AI although I'm fairly particular about some of the features and methods it uses) with a Go backend. Map data comes from PMTiles.

Native APIs exposed via Rust, but the core framework is written in AssemblyScript. Games or mods/libraries built in it are also written in AssemblyScript.

It builds as a binary that can run on the various PC, mobile, and web platforms. You run it and you get a claude-code-like console that has access to a sandboxed filesystem to put game code in, and a git repo, all built in.

It scans your claude and codex history to find edits and matches those to git commits (even if the code was auto-formatted).

https://buildermark.dev/

You can browse all 364 prompts that wrote 94% of the code here:

https://demo.buildermark.dev/projects/u020uhEFtuWwPei6z6nbN

No traffic ever leaves your local network and since it uses rsync under the hood the devices being sync'd to don't need to run anything other than SSH.

It's a single file shell script that has no dependencies except rsync. It's literally 1,000+ lines of defensive checks and validations to make sure you're not shooting yourself in the foot with rsync, and at the end the last line of code directly calls rsync. It doesn't try to reinvent the wheel by replacing rsync (it's an amazing tool).

Members takes turn pitching one album per week. Support comments and a handful of emoji-based reactions.

Integration with Spotify for easy pitching and playing (by links only, users are not required to have a Spotify account).

Plan is to keep the clubs fairly small and invite only.

Building it in Gleam which is a lot of fun!

I'm also working on a 2d procedural animation plugin for bevy, a autotiling plugin for bevy (using 16 tile-dual grid, which the default bevy autotiling plug-in didn't support) and ofc my android pixel editor now has a rig editor mode and a tile editor mode that integrates with the plugins.

Making video games is hard! I keep getting side tracked!

I’ve got a decent amount of people on the newsletter so trying to figure out how to best deliver indie games via that channel and in the end get more people playing these awesome games people develop :)

Right now I'm focused on the stats side. It already shows how much time you spend in each app, and I'm adding website tracking too, which should make the picture much more useful.

I'm also working on better break timing for dictation. LookAway already delays a due break if you're in the middle of typing, so it does not interrupt at a bad time. Now I'm trying to extend that same behavior to dictation as well, which turns out to be a pretty interesting detection problem because it overlaps with some of the other context signals I already use.

Most of the challenge is making it smarter without making it feel more intrusive.

It has some interesting applications for building high performance clients for mssql with tds protocol implementation. The APIs allow almost direct data serialization to wire instead of datatype materialization in rust. Makes for a suitable contender for high performance language interop.

Code: https://github.com/opensciencearchive/server.

Website: https://opensciencearchive.org/

Two demos:

https://pockets.bio

https://lingual.bio

I've got demos up and running (mirroring/extending PDB and GEO). Next I'm working on APIs with good AX, ML-friendly export, and an unified AI-driven UI that works for all scientific data types.

I made a classless CSS library, then migrated most of my projects from PicoCSS.

I also made a quick logo generator: https://logo.leftium.com/logo

https://www.metanoia-research.com/

Also, Arch Ascent, which is a tool for evolveing microservice-heavy architectures.

https://github.com/mikko-ahonen/arch-ascent/blob/main/doc/de...

I'm not a fan of the TUI form factor for longer running, more ambitious features. Even with a classic "Add an endpoint, tweak the infra, consume in the frontend", plans get awkward to refine in markdown files, especially if everything lives in its own repo.

I wanted something like Plannotator, that could also work for the execution, not just the planning, So I've been working on something that turns Notion into the memory and orchestration layer for agents.

Underneath, it's a plan-implement-review loop, but you get a nice Notion page with a kanban board out of it. You can easily link your existing documentation, collaborate by sharing the page, annotate and comment to steer the planner, and you get versioning out of the box.

Because Notion acts as the memory, you can just open the page after a long weekend and get your agent and yourself back into the full context. You can see what's been done, what's left, or what requires human input just by looking at the board. You can ask it to fetch the comments on the pull request you raised, and it'll fetch, validate the comments, give you a report, and update the plan/board if necessary.

I've been using it exclusively for the last two weeks, I'm quite happy with it. It's been really fun to build the exact tool I wanted.

Here's the MVP interface: https://bcmullins.github.io/reading/

I appreciate any feedback. Hope you find something interesting to read!

I wanted to make JSON/YAML configuration language for my projects. And i wanted a strict specification. This is want i created, now with specification and 100% coverage, reference implementation it’s just one prompt to reimplement parser in another language.

https://github.com/flipbit03/terminal-use

I'm super proud, because it came to my knowledge that someone at Codex used my tool to debug codex+zellij issues, by running zellij within `tu`, and then codex inside zellij

The business model is likely going to revolve around mcp and x402 https://micro.mu/developers/

https://lotuseater.epiccoleman.com/

It's a mostly vibe-coded fan site for jamtronica greats Lotus. I wrote/prompted a scraper to pull in setlist data from Nugs and have been having a lot of fun coming up with cool data analysis stuff to do with their sets.

I've seen them 7 times (chump change compared to some fans) and was starting to get certain intuitions about like, "if I hear song X that probably means they won't play song Y." For example, one of my favorite Lotus tunes, It's All Clear To Me Now, seems to fulfill a similar "function" as another song - Did Fatt.

It was pretty cool to see that intuition bear out in the data (they've only ever been played in the same show one time in over 900 total shows).

I've got a bunch of other "data" features sitting in a PR in my Gitlab, need to get around to reviewing and testing it so I can push out the next update. Also have a few other ideas for it, although I think there's probably a point coming fairly soon where there's not really anything left to do.

I posted it on the main Lotus fan group on Facebook. I have a grand total 8 users. I love those users.

The site is nothing crazy, it will never make money or anything - but it's just been a ton of fun to have something cool to hack around on.

I use it daily and so do others, for - better UX, feedback, and review surfaces for ai coding agents.

  1. Plan review & iterative feedback. 

  2. Now code review with iterative feedback.

https://github.com/BVCampos/operator

It has been working quite well.

Repo: https://github.com/jbonatakis/pginbox

Makes reading/searching the Postgres mailing lists easier.

I’m polling a Fastmail inbox to nearly instantly receive and ingest messages. Anyone can browse without an account, but registered users can follow threads to be notified of new messages, threads in which your registered email is found are auto-followed, and there are some QOL settings.

Search is pretty naive right now (keyword on subjects) but improved search is the next big thing on my list.

A solution set to the book Pattern Recognition and Machine Learning by Christopher Bishop.

One thing I find especially intriguing is how LLMs can help deal with desinformation:

- I experiment with deterministic settings of local LLMs for the document summary so that sharing a prompt would prove that the output was not tempered with (no desinformation on the service side)

- I add outputs of several LLMs (from the US, the EU and from China) for the "broader context" section so users could compare the output (no desiformation on the provider and model side)

I think it works quite well so far, but need to tweak the camera algorithm a bit to make the buttons work better. Thinking about more games to add as well.

Once a patch for a security vulnerability is public, the patch itself can reveal the vulnerability before the CVE is published. VCamper uses a staged LLM pipeline to analyze a Git commit range and flag likely vulnerability patches, even when they look like routine changes.

It’s still a proof of concept, but on known cases like curl CVE-2025-0725 it got close to the published root cause from the patch alone.

This matters because LLMs could make it much harder to keep security fixes quiet: once the patch is public, the bug may be recoverable almost immediately. Quietly shipping a fix and hoping it stays under the radar may stop being a reliable strategy.

https://github.com/rndhouse/vcamper

I'm working to make it better right now.

https://channelsurfer.tv/

Lately I’ve been having LLMs implement multiple analysis methods on my session transcripts, trying to surface and identify patterns.

It’s been interesting. It took quite a bit of nudging, but Claude applied techniques I didn’t expect, from disciplines I wouldn’t have thought of.

If it works out, I’d like to turn into a sort of daemon that locally runs analysis on the sessions of users, with a privacy-preserving approach (think federated machine learning).

Would be interesting to see what patterns appear at scale, and have those confirmed or rebutted across thousands of transcripts corpuses. No reason Anthropic & OpenAI should be the only ones to benefit from that; those are our interactions after all.

I've been wanting to do this for years. I fully support (and have paid more than most into) John's shareware, but that means that I can't just "apt install" it, which means I rarely have it available on my various machines. Having something I can just "uv run" that keeps most of the same ergonomics would be a nice alternative.

Already using it for my SQLite driver, and already in use by some a few other projects: https://github.com/topics/wasm2go

It includes bill of materials, purchase/production orders, "can I make n?", stock takes, multiple stock locations, and barcode scanning. It's aimed mainly at small business and makers for the time-being, but still allows multiple users to connect over the the local network.

It lets you create TV channels from digital media such as YouTube, The Internet Archive, TikTok, Twitch, and Dailymotion. It does that by letting you schedule videos against a custom calendar system.

Since filling out even a month of content can be a lot of work, I built some things to make the process easier.

* Advanced scheduler to know when and how long content can be played at any given datetime

* Real time team collaboration

* Channel libraries to organize media

* "Blocks" - Create a dynamic schedule which generate hours of content that mimics real television scheduling. It even carries over your playback history between generations so that playlists continue from where they left off.

* A catalog to find media from official sources on YouTube

* Embeddable as an OBS browser source to restream your owned content

* Repeat content infinitely or temporarily to create 24/7 channels.

If all goes well I am hoping to re-release sometime this month.

https://github.com/Findeton/hebbi

https://github.com/Lramseyer/vaporview

Like PocketBase, it's made in Go, has an admin panel, and compiles down to one executable. Here, you write your endpoints as Lua scripts with a simple API for interfacing with requests and the built-in SQLite database. It's minimal and sticks close to being a bare wrapper around the underlying tech (HTTP, SQL, simple file routing), but comes with some niceties too, like automatic backups, a staging server, and a code editor inside the admin panel for quick changes.

It comes from wanting a server that pairs well with htmx (and the backend-first approach in general) that's comfy to use like a CMS. It's not exactly a groundbreaking project, and it still has a ways to go, but I think it's shaping up pretty nicely :)

link: https://github.com/ksymph/mogo

https://www.flowtelic.com

https://inSolitaire.com

I am currently rewriting+testing the engine and about to add ~400 games to my platform in a few weeks.

The trade-off seems reasonable so far. By going static, the main thing I lose is comments.

The project is still in progress, but I made solid progress over the weekend.

The project is here: https://github.com/yusufaytas/yapress

https://GetSetReply.com/

I am hoping to launch in about a week, so I would love any user feedback! (email in profile)

Official app is mobile-only and clunky, and the workflow is awkward if you're sitting at a desk. Hardest part has been maintaining compatibility across amp models. Small protocol changes or optimizations I make for one amp can break another. That means I have to do a lot of manual testing before every release. So I'm trying to think of an emulation layer or test harness I can build to make my life easier. Happy to hear suggestions there.

About ~50 people are using it so far, and main feedback has been that it's much faster and more reliable than the official app.

[1] https://tonepilot.app [2] https://www.positivegrid.com/products/spark-2

The query engine itself is like a DAG of 'operators', similar to a relational DB (or more like a graph one) with scanners, filters, and matchers.

Very fun, although not at all efficient and probably overengineered for what it does :)

https://prettygoodmusic.app

A work in progress.

Real challenge to keep it working 24/7. The Android OS, and its modifications are really aggressive, trying to kill everything that runs more than they think it is allowed to.

I made a whole article about it. I hope it will help others: https://dev.to/stoyan_minchev/i-spent-several-months-buildin...

Looking for people who know hardware well. Let's get to know one another on a flight to Shenzhen :P

Very early demo with a smart dum-dum RL agent here:

https://rlplays.com

Eventually I got scope creeped into a full game with branching stories, item crafting, and a custom cutscene engine...even Trained a model for a few specific art assets.

https://store.steampowered.com/app/4301600/Cherrys_Dungeon/

https://radiantskin.app/

Fully local, hobbyist friendly, agentic workflows work great with it since it’s just a CLI.

Orange Words. My hobby project, a hacker news search system. It was initially created by hand and now I use AI augmented development. It's a good low risk environment for experimenting.

https://agjmills.github.io/trove/

Go, docker, bit of alpine js

It's still VERY much in development but I'm building a site that allows people to find TTRPG games that are suited to them AND includes a suite of tools for both GMs and players in said games.

Players will be able to showcase characters they're playing or have played and GMs can manage campaigns (scheduling, notes). I'm a D&D player but I'm trying to make it system-agnostic

It gives you a detailed breakdown of what's missing, step by step guidance on how to fix each issue, and shareable report links. Excellent resource for security teams of all sizes.

Scans HTTP headers, TLS/SSL, DNS security, cookies, and page content. Free to get started, with a REST API for integrating scans into your CI/CD pipeline or monitoring. Also supports capturing and reporting CSP violations.

I do a lot of data science and analytics in my real job.

Swiss army knife CLI tool written in Swift using only native Apple frameworks.

The primary goal of this project is to demonstrate how many Apple standard library frameworks can be meaningfully used in a single, actually-useful CLI tool.

brew install jftuga/tap/swiftswiss

It's called MatGoat[1], and it's going quite well so far. Nowadays I'm working more on the marketing/sales side.

[1] https://matgoat.com/en/

Program your amateur radio via the web. Uses pyiodide + chirp drivers under the hood + WebSerial.

It's in rust with egui, and should help folks to do that without the cli.

Not ready for prime time yet, but available at https://github.com/almet/signal-without-smartphone

https://cybernetic.dev/cube

The mission is to incentivize better thinking. For each game there's an AI judge that scores everyone's answer based on a public rubric (style, cohesion, logic, etc).

Currently uses fake money and ELO score but thought it could be a very interesting competitive game for real stakes.

Any feedback is much appreciated.

An international calling app, for the poor people

- make it reliable to run LLM inference on company hardware, even when it is poor or outdated

- bring chaotic agentic behavior under control in business contexts

https://github.com/netdur/hugind

https://buttplug.io

https://github.com/VoxleOne/SpinStep

Posted a show hn earlier today that didn't got any traction : https://news.ycombinator.com/item?id=47738516

https://grge.github.io/weierstrass/

https://fluenly.ai/

and a gift for my friend's birthday.

A tool to estimate if you should vibe an automation/app or just buy/delegate/grind instead

Turns your project's GitHub release notes into user changelog that your users actually want to read.

Deployment tool with security gates.

https://apostrophecms.com

Six months ago, that would have been unrealistic, because we're heavily committed to the mongodb API and we make it part of our own API.

Starting in December though, Opus 4.6 made it perfectly realistic to pursue this with Claude Code as a series of personal weekend projects.

Now, despite not having any official resources on this until the last week or so, it should land in May.

This doesn't work for everything. It absolutely helps that the problem I'm solving is an "adapter pattern" problem: "make X talk like Y." And that we have a massive test suite, at multiple levels. That combination makes "here's the problem, go solve it, grind until the tests pass, don't bother me for a few hours" a realistic AI agent request.

But it's a little mind-blowing all the same. The hype around AI is so out of control, it can be easy to miss genuine "holy crap" moments.

Along the way I've written a fair bit about how to run Claude Code autonomously on your household server in a reasonably secure manner:

https://apostrophecms.com/blog/how-to-be-more-productive-wit...)

Also general Claude Code tips and thoughts on workflows that help and workflows that ultimately just speed your burnout:

https://apostrophecms.com/blog/claude-code-part-2-making-the...

I know, everybody's writing this stuff, but the desire to share is natural.

(Disclaimer: I'm part of the demographic AI was trained on. If I tried not to sound like a bot, I'd have to sound like... well, somebody else)

I deliberately separated it from my public internet persona (which is connected to my real name) in the hopes that I could write about weird, woo-y, or controversial topics without worry. I've got a few articles half baked and have been having fun engaging with a different subset of the Substack crowd than my normal tech focus would show me.

Of course the stats show that the one article I did that touches on AI has done an order of magnitude better than anything else.

Anyway this is just kind of a weird sideline project, a sort of release valve for stuff that wouldn't fit in on my "professional" site, but it's been a fun thing to spend some time on.

Another thing that's cool is that I largely stopped _writing_ a few years back. I always enjoyed writing but of course as a dev most of my stuff had a technical/tutorial bent to it. Writing weird little "what do I think" essays has forced me to exercise a writing muscle I really hadn't stretched for a long time and I've enjoyed it.

There's only a handful of things up now, it's nothing special really. Link in my bio, if you see something you like I would love to hear from you!

Some months ago, I saw that very popup, and finally started working on something I've been wanted to do for a long-time, a spreadsheet application. It's cross-platform (looks and work identical across Windows, macOS and Linux), lightweight, and does what a spreadsheet application should be able to do, in the way you expect it, forever. As an extra benefit, I can finally open some spreadsheets that grown out of control (+100MB and growing) without having to go and make a cup of coffee while the spreadsheet loads.

I don't really have any concrete to share, I guess it'll be a Show HN eventually, but I thought it was funny it was brought up in a similar way in that article as was the motivation for me to build yet another spreadsheet application.

https://www.geosystemsdev.com/products/hodlings/

In essence, it runs on your mobile device and stores all your data locally. It only connects to the freely available CoinGecko API (for latest prices) and GitHub (for reference and historical data). A background job updates GitHub ref data hourly. There's no login, no cloud, no ads, etc.

It's an LLM-webapp-builder, sure, but different from the rest! I have the LLM write python code when it needs to modify an HTML file for example (it'll use beautifulsoup; then I run the code: it parses the source into a data structure, modifies the data structure, and then outputs the resulting html).

It's also a marketplace where you can publish your llm-powered webapp, and earn $ on the token margins (I charge 2x token rates) when people use your site.

The idea: describe any problem in plain language (voice or text), and AI codifies it into a structured program with the right people, steps, timeline, and agents to get it done. It's a 5-step wizard: Define Problem → Codify Solution → Setup Program → Execute Program → Verify Outcome.

It runs across 50+ domains — codify.healthcare (EMR backend), codify.education (LMS backend), codify.finance, codify.careers (HRM backend), codify.law, plus 13 city domains (codify.nyc, codify.miami, codify.london, codify.tokyo, etc.). Each domain tailors the AI assessment and program output to that sector.

The platform is Project20x — think of it as the infrastructure layer. If Codify is the verb ("codify your healthcare problem into a care program"), Project20x is the operating system that runs it all: multi-tenant governance, AI agent orchestration, and domain-specific sys-cores for healthcare, education, city services, etc.

Every US federal agency and state-level department has a subdomain — ed.usa.project20x.com (Dept of Education), doj.usa.project20x.com, hhs.usa.project20x.com, etc. — with AI agents representing each agency's mandate. Same structure at the state level.

The political side: Project20x hosts policy management for both parties — dnc.project20x.com and rnc.project20x.com — where legislative intent gets codified into executable governance through a 10-step policy lifecycle. Right now I'm building out the multi-agent environment so agency agents can negotiate with each other, make deals, and send policy proposals up to the HITL (human-in-the-loop) politician for approval. Each elected official has a profile (e.g. https://project20x.com/u/donald-trump) where constituents can engage and where policy proposals land for review.

The name is a nod to structured policy frameworks, but the goal is nonpartisan infrastructure: democratically governed essential services delivered as AI-native social programs.

Stack: Nuxt 2/Vue 2 frontend, Laravel 10 API, Python/LangGraph agent orchestration, Flutter mobile app. Currently live across all domains.

https://project20x.com | https://codify.healthcare | https://codify.education | https://dnc.project20x.com | https://rnc.project20x.com etc...

https://drivelens.click/

No file contents are accessed, only metadata, fully client-side API calls (browser to google API).

Direction - I’m trying to teach people how to do all the other stuff that you need to know, other than writing code, about delivering real products and not just a bunch of junk and slop that can’t be maintained

ShowHN: https://news.ycombinator.com/item?id=47721469

I’m also trying to make it really super simple so it’s week to week pricing, and have a discord community that grows out of it.

It’s literally just four two hour courses on Monday of each week and a demo day.

you walk through what you’re gonna do, how you’re gonna do it, how you’re gonna use your AI assistants to help you, where it can help you, and where it can’t help you, how to talk to it about teaching you instead of just doing it for you, and at the end of it you have something tangible to show for it.

There’s no subscription this is just straight up teaching product and project development that comes with a community and the community grows as much as it chooses to.

You can read the vision and roadmap on the site as well

https://www.givedirection.com/vision.html