Always on the look for new sources to be added. If you have a blog or read any that you want to recommend. Just let me know.

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.

https://fillvisa.com/demo/

https://www.puzzleship.com/

Currently experimenting with a proactive agent, Don, that pops up like clippy and also works over email.

https://donethat.ai All the data security measures here: https://donethat.ai/data And other tools out there: https://donethat.ai/compare

I just updated the RAW pipeline and I'm really happy with how the resulting photos look, plus there's this cool "RAW+ProRAW" capture mode I introduced recently.

https://apps.apple.com/us/app/unpro-camera/id6535677796

I initially released it early last year and have been using it as my main camera app since, but I haven't mentioned it in one of these threads before. Unfortunately this post has come just a bit early for my most recent update to be approved; there's some nice improvements coming.

I'm enjoying building a website with solitaire and puzzle games.

I am currently rewriting the engine for the fourth time and plan to add 400 games to the platform in the coming months, as well as social features such as daily challenges, awards and leaderboards.

My main goal, however, is to make this project the largest collection of free modern solitaire games available for mobile devices and desktop computers.

So far, the project has been incredibly exciting, and I've learned so much!

https://www.inclusivecolors.com/

There's millions of tools that try to autogenerate colors for you using algorithms and AI, but they usually ignore WCAG accessible contrast requirements, don't let you customise the tints/shades, don't let you create a full palette of colors, and the colors often don't look right on actual designs.

This tool is meant to make customising tints/shades intuitive and quick enough in a few clicks via a hue/saturation/lightness curve editing interface that you won't want to rely on autogeneration. There's also a live mockup showing how your palette looks on a UI design that checks pairings pass contrast requirements, to guide you as you tweak your colors and to teach you the WCAG rules.

You can then export your palette to regular CSS variables, Tailwind, Figma or Adobe for use in your designs.

Really open to any feedback on features that would be useful! I think the only way I can make it simpler to use is to make it more opinionated about how your palette should be designed so interested in any thoughts about that too.

https://euzoia.substack.com The concept: https://euzoia.org

Tried to do this as low tech as possible, so website is just an off the shelf notion wrapper

You get to choose the genres you're interested in, and it creates playlists from the music in your library. They get updated every day - think a better, curated by you version of the Daily Mixes. You can add some advanced filters as well, if you really want to customise what music you'll get.

It works best if you follow a good amount of artists. Optionally you can get recommendations from artists that belong to playlists you follow or you've created - if you don't follow much or any artists, then you should enable that in order for the service to be useful.

https://riffradar.org/

We are experimenting with Keybase key holders as CAs:

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

And also .gov email holders:

https://blog.certisfy.com/2025/12/using-gov-email-addresses-...

It's all self-service and requires no sign-up or download of anything, the app (https://certisfy.com/app) is an in-browser app and all the cryptography happens in the browser.

https://minfx.ai/

    MetalLB - https://metallb.io/ load balancer

    Traefik - https://doc.traefik.io/traefik/getting-started/quick-start-with-kubernetes/ ingress

    Local Path - https://docs.apps.rancher.io/reference-guides/local-path-provisioner storage

First game is https://geocentric.top where users can sculpt a planet collaboratively and place trees or houses (for now very limited). I plan on making it an idle sim where players will be able to interact by dropping some food/events for the creatures on it to evolve through time.

Second, a remote logger/metrics/user management tool where once can track all their logs, live metrics, uptimes, identify users, etc. I hope to have a v1 during this first quarter and I'm currently my first user as I have it hosted at https://app.getboringmetrics.com to centralize all my side projects into a single platform.

I wrote the firmware in Arduino, which was a great learning experience because I typically work with CircuitPython or Go, where I'm less constrained.

Used ai to create my own mind mapping tool for private use.

I also created a private cursor-like / loveable-like tool that I can use for my own vibe code prototyping on the go with my phone.

https://desktop.with.audio

Holidays nuked all the hot-cached context in my head. I spent a few days just spinning wheels until it repopulated. But the basic idea works now!

Much testing and benchmarking work remains to make sure it's not going to lose data, and that it won't denial-of-service itself (because object-map -> facts fan-out is big).

Also a second giant blog post is due (following the one discussed above). Lots of notes have accumulated.

It will be fun even if the concept ultimately crashes and burns to the ground :)

In which case, there's always datomic and xtdb :D

  (def repl-facts
    [{:alt.site.evalapply/meta
      {:description "Root namespace for a named site."}}
     {:alt.site.evalapply/features
      {:paid #{:alt.site-feature/feat-1
               :alt.site-feature/feat-2
               :alt.site-feature/feat-3}
       :trial #{:alt.site-feature/feat-4}
       :complimentary #{}
       :available #{}}}
     {:alt.site.evalapply/users
      {:authorised #{:alt.user.evalapply/user-1
                     :alt.user.evalapply/user-2
                     :alt.user.evalapply/user-3}
       :unauthorized #{:alt.root.*}}
      :alt.user.evalapply/user-1 {:name {:first "Wiley"
                                         :last "Coyote"}
                                  :roles #{:alt.role.evalapply/owner}}
      :alt.role.evalapply/owner {:rw #{:alt.user.evalapply/*}
                                 :ro #{}}}])

  (assert-facts! (#'user/system-state)
                 ::app
                 :alt.root/user-1
                 (uuid/v7)
                 repl-facts)

  (redact-facts! (#'user/system-state)
                 ::app
                 :alt.root/user-1
                 (uuid/v7)
                 (subvec repl-facts 2))

  (read-now! (#'user/system-state)
             ::app)

Top of my ideas now: add "ask your LLM" buttons to my email submission form that opens ChatGPT/Perp/Claude and auto-fills a query asking it why you should be friends with me.

Sample links (I hope it says nice things about me!):

Claude: https://claude.ai/new?q=Do+deep+research+on+a+person%2C+dvsj....

ChatGPT: https://chat.openai.com/?q=Do+deep+research+on+a+person%2C+d....

Also working on a PRM. My website is https://dvsj.in - open to any feedback!

It works with your existing phone system, so you can just add AI as a line without having to replace everything…

1. https://sip4ai.com

As a hardcore AI chat user, I'm often frustrated with the single-agent workflow, where a single context window is used for even very long conversations. If I want to change the topic, open a thread, or go on a tangent, I often end up compromising the main thread and I'm forced to copy context over if I want to dive into something.

To solve this, I'm working on a collaborative AI agent orchestrator that models the solution as a group chat with humans and AI agents, including an agent orchestrator.

You can spawn participating agents with the orchestrator who will decisively route messages to the existing agents, or spawn new agents if needed. Also, you can open agent details and send messages directly to existing agents, similar to threads in slack.

So far, I have MCP integrations working with Linear and GitHub, but plan to add many more.

I've been working on this just over 2 weeks, making heavy use of 4+ concurrent Claude Code agents. This would have been impossible otherwise.

If you're interested, feel free to DM on X.

https://x.com/jon_ator/status/2010370649147998459?s=20

Source code, in rust: https://github.com/David-OConnor/molchanica I've split out its building blocks into their own libraries on crates.io, for anyone building other bio or chem software. I don't think anyone uses them at this time.

Obviously, it all comes with its own sets of issues, but I am working through those as they come. But it is still a slow move solo.

Also, a dramatic anime intro (complete with cheesy AI generated theme song and video) starring our foster kittens. It's been interesting to learn about some of the techniques needed for consistency, how to storyboard, etc.

Most of my work so far has been on the actual music-making interface, but I'm beginning work on the backend now. I've only worked with Django before (for a school project at Georgia Tech), so I'll be deep in the `sqlx` documentation for a while.

There's no manual, so use at your own risk (it's similar to tracker programs like FastTracker and OpenMPT): https://mondobe.com/tracker

I recently added better backend support for deployments, converted everything to async Rust, and setup Nix/Docker releases. I'm planning to build out some better example apps and workflows next, but everything will stay pre-alpha/unstable for now so that I can avoid getting locked in to any foundational issues. There are still a number of low-hanging breaking issues blocking the end-to-end usage which I'll need to address.

https://github.com/arcuru/eidetica

- https://github.com/rcarmo/gotel (an OpenTelemetry tracing collector/UI, under heavy refactoring)

- https://github.com/rcarmo/toadbox (a simple Docker-based agent sandbox to run Toad/OpenCode/Mistral inside, which I've been cleaning up for general use)

Started playing with gas town which is really cool. I had a naive version built that was just not good enough. This feels like a step in the right direction.

Haven’t had much time to work on any of my physical hands on hobbies lately but maybe when the weather gets better I’ll head back out to the shop again.

The most difficult technical challenge has been designing a pipeline to fully automate choosing test & control locations using synthetic difference-in-differences.

You get tailored running schedules and also some body weight strength workouts and healthy meals all in one!

https://cybernetic.dev/helix

https://shepherd.com/

Building a really unique book recommendation platform to help readers find books they might not otherwise know about. We just started working on a full book app that will be a private book diary, along with recommendations and insights based on your Book DNA. Think Goodreads, but rebuilt for readers who want a private space to track what they read, keep notes, and get truly personalized book recommendations (like Pandora or Spotify for books).

https://downforeveryoneorjustme.com/

This is a fun one I do with a good friend. Basically, to see if a website is down, or if it is just you, along with reported reasons from the community. We are working to add user accounts so you can create your own custom lists of websites/services to track

[1] https://github.com/smartcomputer-ai/agent-os

Here are the links.

Chrome store: https://chromewebstore.google.com/detail/video-notes/phgnkid...

Firefox store: https://addons.mozilla.org/en-US/firefox/addon/video-notes-f...

I actually would love some feedbacks and suggestions from someone here :)

I've got a nice ingest, extract, enrich process going for the graph - I'm currently working on a fork of claude-mem[1] that uses the graph as a contextual backend for agentic coding workflows.

0. https://arxiv.org/abs/2508.04118 1. https://github.com/thedotmack/claude-mem/

I have GBs of time-series data in a TimescaleDB database. It’s more complicated than this, but the gist is: I use natural language to ask questions about relationships in the data, Claude Opus 4.5 generates queries, and it finds patterns.

For example, I classify tens of thousands of news articles using different classification models. Then I ask Claude to write a query that tests for statistically significant changes in the time-series data at specific intervals after a given classification of article—and it finds patterns.

It passes train / test split validation. It will train on 2 years of data (2023 and 2024) and being able to effectively predict movements on the time series data using the classified news articles on the last year of data (2025).

- WIP: A FOSS, self-hosted Luma alternative (for use across our community initiatives)

I have a few other small side projects that generally improve my day-to-day life, including a better calendar widget for shift workers and a video speed controller that floats on websites where I frequently watch videos for easy access.

At Sylvester I stopped smoking.for the beginning and hard times I searched for a deflection and started with my own quitesmoke app - purio

I released it some days before a reached a workable state.

Here the result, if you want to check:

Android: https://play.google.com/store/apps/details?id=io.codingplant...

Feedback is welcome

Attracting new monthly sponsors and people willing to buy me the occasional pizza with my crappy HTML skills.

https://brynet.ca/wallofpizza.html

I have built a multi language bdd test framework. A human can write the bdd specs and an LLM will generate the code to match.

I am unsure if there is a need for a tool like this in the market but I am becoming more and more curious around databases so this felt like a lower barrier for my product-minded engineer skills to get into.

https://github.com/JWally/jsLPSolver

I'm tinkering around building "JARVIS" (I didn't want to come up with a clever self deprecating name - this works) - a personal project to manage my life. Integrates into Google Mail, Google Calendar, Trello, GroupMe, EveryDollar. Basically it nags me to do grown up thing and is a better UX than Google Calendar/Trello - I just talk to it and ask it things.

Also experimenting with a new Claude-Code flow; give the bot its own AWS account, Put a bunch of tickets on my personal JIRA, be persnickity about what constitutes "pass" and tell the bot "follow these instructions, pull down tickets until there are no more. Your branch cannot merge until you have integration tests passing in your own dev env first" (I use AWS CDK). Then let it loose to build. The instant feedback loop that Claude has with Build-Code->Deploy to AWS->Run Integration Tests->Address Failures is really nifty fwiw...

So I built a SEO/GEO Automation Tool for Small to Mid-Size Businesses who don't have a full-time team for that. [0]

The goal is to provide teams visibility across all the channels — Search and AI and give them the tools needed to outrank their competition. So far so good, the fully bootstrapped venture has grown over the last year and I've built quite a few big features — sophisticated audit system, AI Responses Monitoring, Crawler Analytics, Competitors Monitoring etc.

[0] https://seojuice.io

https://www.journable.com/

The interesting technical bit: it analyses your historic general ledger to reverse-engineer how you specifically categorise transactions. So instead of generic rules, it learns your firm's actual patterns - "oh, they always code Costa Coffee to Staff Welfare, not Refreshments" - that kind of thing.

Posts directly to Xero, QuickBooks, Sage, and Pandle. The VAT handling turned out to be surprisingly gnarly (UK tax rules are... something).

Been working on it about 6 months now. Still figuring out the right balance between automation confidence and "just flag this for human review".

PrintRelay consists of a cloud server and lightweight clients that connect printers to the cloud via WebSocket.

We use the excellent SaaS PrintNode at work, but about twice a year we have connectivity/routing issues between AWS ap-southeast-2 and their servers OS. PrintRelay is my attempt to not need PrintNode. Because of this PrintRelay is PrintNode API compatible.

1. https://github.com/schappim/print-relay

I've always had a bunch of small side projects that I want to do that aren't worth the overhead required to actually put them together & keep them maintained. So, I built a small Lua-based FaaS platform to make each individual project less work whenever inspiration strikes. So far I've built:

* A current-time API for some hacked-together IoT devices: https://time.bodge.link/

* A script for my wife that checks her commute time and emails her before it's about to get bad.

* An email notification to myself if my Matrix server goes down.

* A 'randomly choose a thing' page. https://rand.bodge.link/choose?head&tails

* A work phone number voicemail, the script converts the webhook into an email to me.

* An email notification any time a new version is released for a few semi-public self-hosted services.

* Scrapers for a few companies' job listings that notify me whenever a new job is posted matching some filters.

* A WebPush server that I eventually want to use for custom notifications to myself.

* An SVG hit counter: https://hits.bodge.link/

Since I'm already maintaining it for myself, I figured I might as well open it up for others. It's free to play with, at least for now.

I think that Acme is very underrated in its domain (a tool for experts). The coverage is minuscule. That’s why I am thinking about blog posts, maybe video tutorials. I do not know what should it be exactly.

I do not have any time estimates. I have a very demanding main job (I work as a software developer) and young family that I need to take care of. This project demands focused efforts and selectivity that I can barely satisfy. But I wouldn’t give up, the thing is totally worth it. If it’s going to take years, so be it.

If you have any comments, send me a letter at kalterdev@gmail.com. Have a good day.

1: https://9p.io/sys/doc/acme/acme.html

https://github.com/ityonemo/clr

2. Molecular biology editing software. Will plug in to agentic ai workflows

A live-performance software with a focus on creating 'musically connected visuals'. Currently, the biggest connectivity is probably tightly tied lyric visualizations. Some recent examples:

https://www.youtube.com/watch?v=mRHLzuUBz5o - She Wants Revenge - I don't want to fall in love

or if you prefer Mashups:

https://www.youtube.com/watch?v=e_Xq8Dh4NEw - The Lovemakers – Shake That 50 Cent (50 Cent vs. The Lovemakers)

Finally, we decided to open source the exe.dev agent, Shelley. https://github.com/boldsoftware/shelley

https://git.sr.ht/~tombert/feocask

Called "feocask" cuz feo means "ugly" in Spanish and FeO to mean Iron Oxide for Rust. I thought it was funny.

I will admit that I had help from Codex, but I did write most of it myself, and I think the design is coming out kind of neat. I have a very strict "no lock" policy [1], including lockfiles, and this should still be safe to use across any number of threads, at the cost of N^2 reconciliation to the number of threads and a lot more drive space.

I like my design; I have an excuse to use Vector Clocks and Hybrid Logical Clocks and I think it might actually be useful for something some day. I'd like to eventually write something that goes a bit beyond getting parity with bitcask and optionally have the ability to automatically distribute across multiple nodes, but I'm still trying to think of a good design for that, because my current design depends heavily the atomicity of POSIX filesystem commands, and introducing the network introduces latency that would likely greatly degrade performance.

[1] At least no explicit locks. I am using Tokio channels and they are probably using locks in some spots behind the scenes.

I've also built a RISC-V emulator to integrate with this platform, so eventually it'll be able to run native binaries written in any language, completely sandboxed, completely built around message-passing. Basically a native, low-level BEAM-like platform to build an entire operating system and user-space.

While my day job is writing boring applications, this is the stuff that keeps me awake at night, and I would love so much to talk and write more about this, about the trial-and-errors I'm facing, but it's still so much in flux every week I'm exploring a new approach. Most of my work has been around the stackless scheduler, and I have a plan to achieve preemption for long-running or misbehaved tasks without having to compromise on memory usage (i.e. without giving each process its own stack and allocate memory for context switching).

Eventually I'd like to layer on top either Cap'n Proto or another high-performance serialisation system to create a distributed, introspectable environment of object-capabilities that are sending typed messages between each other, achieving the ultimate goal of creating an unholy hybrid between Smalltalk and the Erlang VM.

God, how I wish I was paid to work on this type of problems :-)

If this sounds close to your area of interests, please send me an email and I’d love to chat.

My Family recently (in the last couple of years) started to breed Ragdoll cats in the U.K.

In an attempt to support what's involved in this I built Ardent for them. It covers a bunch of the day-to-day concerns (weighing and health tracking), Lineage and Inbreeding prevention, and Owner Pack generation for handovers to new Owners.

So far I can see magnetic fields on a magstripe https://www.youtube.com/watch?v=c8nM4Z-hkTw with two polarisers (one of which I rotate in the video, which is contained in a 3D printed holder with gears I made).

I'm awaiting some different polariser film, to see if I can get it to work with a floppy disk.

https://marcelv-net.translate.goog/index.php?w=apparaat&id=3...

https://github.com/jaggederest/locque

A hobby project I started putting together late last year; a little spot on the internet for prayer and reflection.

https://dugnad.stavanger-digital.no/

A pro bono tech consultancy for local non profits. The idea is to help them use tech to better deliver on their mission.

One always-on Linux box to run apps, databases, CI, and AI agents without hyperscale complexity, surprise bills, or Kubernetes. AI-driven app explosion plus mature open-source deploy tools make simple servers fast, cheap, and fun again.

consistently getting traffic of 30k in a month with peaks upto 10k in a day

This has been on for a few months now but I'm thinking to add new features as users are asking for multiplayer support. Would love some feedback

[0]: https://www.hotlapdaily.com

--- Todo or else ---

The main thing is a new Go CLI called "todo or else". It scans your project for TODO comments and checks that they have deadlines

This allows you to hold yourself accountable for completing them

You can verify other things like whether TODOs have owners

I'm using Tree Sitter which means it can handle most programming languages (although, I'm shipping with a subset, as the grammars can get quite big)

I'm hoping to release this cross platform in a couple of weeks

--- Video: How PSX games were developed ---

A ten minute YouTube video about how PlayStation 1 games were developed

The tools, languages, and practices that were common in this era

Also the computers, software, programs used for creating assets (eg Irix Framethrower for SGI)

I'm hoping to produce a 10 minute video on my YT channel (jbreckmckye). Currently in the writing stage

--- Black Noise ---

A small, command line program for playing white noise

I think it would be a nice utility to have for focus sessions... maybe to double as a sort of pomodoro timer

It’s a super simple job management app for busy tradespeople to keep track of jobs.

The main use case is time pressed tradespeople who do most of their admin in the evenings.

The app makes capturing leads incredibly easy and quick. Lots of scope for extending functionality in the future in various directions.

(Not launched yet, squashing bugs and refining a few bits and pieces)

Comparing world countries on as many uncorrelated statisticals factors I could get my hands on.

Fun fact: in overall top 10, there is only one country that is not in Europe.

Currently I'm working on following features: - Multi user support (Team) on project level - Then I'll look into whether to add support for OIDC/SSO now or not - Alert on slack - Webhook support

0: https://daestro.com/

Also working on a red chamomile (using beat red biosynthesis). Just for fun. Red chamomile tea!

The idea is to have niche invite-only genetically engineered flavors that I can bring to parties around SF :) what’s more special than a genetically engineered organism that you can ONLY get if I’m there? Good calling card

You put in all your bookmarks (also pdfs or epubs) and it puts them in a queue and tracks your progress. Read for as long as you want to and if you get bored with an article you just move on to the next one. Supports highlights and annotations as well as creating spaced repetition cards out of those annotations.

Really reduces the friction for me to start reading and it has made a noticeable difference to my media consumption throughout last year.

Started out as an exploration into the incremental reading concept, but it's become my primary interface for reading and I use it every day.

I haven't really talked about this to anyone yet, but it's getting to a point where it's polished enough for others to use.

It's currently completely free and you can try it without entering your email.

https://www.increader.com/

It’s text based, so it is basically an advanced editor/viewer for one long text note.

https://apps.yozy.net/swolog/web/

Birdhouse: https://img.notmyhostna.me/cRQ1gJfZCHjQKwFrgKQj

UI:

- https://img.notmyhostna.me/Hnw4qcvbg1ZQCrFxzGMn

- https://img.notmyhostna.me/62TFwSXSRRbCfxDz297h

- https://img.notmyhostna.me/40qhgHmSqQsrGr8BC7Db

- https://img.notmyhostna.me/9bgz4GYsjQH33n3MtWKp (Face labeling, so I can show thumbnails of the actual birds that visited and train a ML model on it in the future)

AI models and open source robotics for food production.

From backyard gardening, subsistence farming, urban gardening, and other forms of small scale agriculture.

We believe no one owns nature and that all growers have 100% right to repair any equipment we offer.

Our first IOT device (greenbox) is in an open beta for 2026. Please reach out to support@gthumb.ai if interested.

Happy for alpha users; it's really early days right now. Email in profile if you want to give it a try at no cost.

Im launching a new word game next week which I’m super excited about. If you do play it and have any feedback do shoot me message!

https://github.com/WillAdams/gcodepreview

Hopefully I can restore the OpenSCAD interface layer and get it working with OpenSCAD Graph Editor:

https://github.com/derkork/openscad-graph-editor

again. Having trouble finding FCG examples which do more than move in straight lines though...

https://github.com/storytold/artcraft

AI tools are becoming incredibly useful for our industry, but "prompting" without visual control sucks. In the fullness of time, we're going to have WYSIWYG touch controls for every aspect of an image or scene. The ability to mold people and locations like clay, rotate and morph them in 3D, and create literally anything we can imagine.

Here are a bunch of short films we've made with the tool:

- https://www.youtube.com/watch?v=tAAiiKteM-U (Robot Chicken inspired Superman parody)

- https://www.youtube.com/watch?v=oqoCWdOwr2U (JoJo inspired Grinch parody)

- https://www.youtube.com/watch?v=Tii9uF0nAx4 (live action rotoscoped short)

- https://www.youtube.com/watch?v=tj-dJvGVb-w (lots of roto/comp VFX work)

- https://www.youtube.com/watch?v=v_2We_QQfPg (EbSynth sketch about The Predator)

- https://www.youtube.com/watch?v=_FkKf7sECk4 (a lot of rotoscoping, the tools are better now)

Public dataset for exploring 50,000+ 401(k) plans holding $7.5T in assets.

You can look inside a company like Google and see what employees invest in (mostly 2035-2055 target date funds) or how much they contribute ($30K - likely using Mega Backdoor Roth)

https://www.401k.live/plans/google-llc/

https://arxiv.org/abs/2512.24601

https://vimeo.com/1147473608?fl=pl&fe=sh

It started as curiosity. I wanted to see if I could express business logic as simple choices and let the numbers fall out on their own.

The app is built interactively in Streamlit. I do not sit down with a spec or a backlog. I add one small idea at a time, refresh the page, react to what looks wrong, then adjust. It feels closer to sketching than programming. The interface tells me what the logic should be next.

Underneath there is a growing pile of rules about the business I am in.

I do not write code in the traditional sense.

I have never coded before and are solving my own problem done by one, this sure feels like magic!!

I blogged about the whole build and coding project [here](https://partridge.works/screenie-christmas-project-2025-26/)

Code for the Arduino and also the web app is Open Sourced [here](https://screenie.org/get-device/selfbuild)

And you can play with it [here](https://www.screenie.org)

I found myself switching a lot between apps to get the same info, lots of copy/pasting.

Example, URLs in bookmark (which I forget about), project descriptions , images, folders.

So I built a Mac app that is similar to Raycast, but just for notes. If I want to save a webpage, I click control+option+C and then a window pops up to describe it.

If I press control+option+V, I get a spotlight like window where it does full-text search of all my notes and descriptions and filter so I can either:

- Open

- Insert the data into the current app (chrome, slack, ChatGPT).

I’ve been using it for a few weeks now, and not sure if others will find it useful.

Building something is a nice break from the corporate world.

https://blazingbanana.com/work/whistle

Currently tidying up some internal code (also removing the larger model on mobile platforms) and implementing proper diarization (who said what) so that it can be used for more than just personal dictation.

My iOS developer account is _finally_ approved so it will be available through the proper app store soon.

Finding other co-founders based on proof-of-work

Overall, Minifeed keeps chugging along, fetching new posts every day from almost 2k feeds. I'm hoping to find some nice and ethical monetization strategy for it this year.

[0] https://cloud.typesense.org/

[1] https://github.com/bfritscher/typesense-dashboard

The stack is Babylon + React + Capacitor, which was easy to step into as a full-stack dev with zero game building experience. Currently seeing what I can do to fix some performance issues, though it still works decently for a graphics heavy incremental/idle game.

Beta is still open for Test Flight. Can sign up via https://blossom-beta.blindsignals.io

https://www.futile.com/patch

- Skyscraper, an iOS native app for Bluesky with focus on Liquid Glass UI. Launching hopefully in a ~week, and TestFlight available at https://testflight.apple.com/join/RRvk14ks

Then also working on a website/web tool that does the following: - A keyword/term notification service that observes the Bluesky Jetstream for usages of the term and sends email alerts.

- Provides an HTML/JSON backup archive of any Bluesky account. Quick way to archive popular accounts, politicians, public figures, etc.

- Trending Hashtag lists, to see what is trending the last hour, day, week, and month.

The web services all are available at: https://api.getskyscraper.com/tools/

https://soatok.blog/2025/10/15/the-dreamseekers-vision-of-to...

Running on a single-core armv7. It includes a VIO and a nice loop closure. I am now optimizing it further to see if I can fit some basic mapping too.

It's an IoT Cloud Platform built for developers. We're still in technical preview and are currently working on adding more telemetry to our small device agent written in Rust.

Check out our docs at: https://fostrom.io/docs/

One aspect that HN may find interesting is my use of Bayesian optimization to control and perfect key experimental settings. About a dozen of the wave plates and other optical components are motorized and under computer control.

Given a goal metric like "maximally entangle the photon pairs" the optimizer will run the experiment 50-100 times, tweaking the angles of various optics and collecting data. Ultimately it will learn to maximize the given cost function.

This sort of thing is commonly done with tools like Optuna during NN/LLM training to optimize hyper-parameters, but seems less common in physics especially quantum photonics. I'm using a great tool called M-loop to drive the optimization, which was originally developed for creating Bose-Einstein condensates.

https://github.com/michaelhush/M-LOOP

One piece I helped with is SenL, a “sensitivity level” framework for AI labs. It’s like a practical clearance system for AI assets. Not everything in a lab is equally dangerous, so you label assets by sensitivity (weights, training data, eval sets, agent tooling, deployment configs, etc.), then tie that label to concrete controls like who can access it, where it can run, what logging is required, and what monitoring / two-person rules apply.

If anyone’s curious, SL5 is here: http://sl5.org/ and the SenL framework is part of the published artifacts.

The idea is to rely on kernel Wireguard, and process packets in kernel space (via eBPF) for maximum performance and minimal CPU overhead. I plan to use egress and ingress TC to “apply” the policy at both sides. XDP is faster, but only works on ingress, which is not sufficient for a mesh VPN imo.

Netbird already exists in this space, so this is mostly a learning exercise, and maybe a reference implementation for those learning eBPF in Rust.

Goals and constraints:

1. Single digit CPU overhead for multi Gbps bandwidth (probably a bit too ambitious, but we’ll see)

2. Linux only

3. No hole punching or complex NAT handling

4. Basic policy language for L3 and L4 traffic (L7 requires punting packets to a userspace proxy)

https://github.com/scallyw4g/bonsai

https://github.com/scallyw4g/poof

For a couple of years now, I’ve wanted to build a service that lets you subscribe to new version notifications for any kind of software—desktop apps, drivers, packages, and more. As a Unity developer and consultant myself, I’ve always wanted to know the moment a new version becomes available. I value being at the bleeding edge, especially since a large part of the value I bring as a consultant comes from both the breadth and depth of my knowledge of the Unity engine.

That’s why I’m currently working on a niche version of the broader VersionAlert idea specifically for Unity, which is why the domain currently redirects to https://versionalert.com/unity .

The only other service I’ve found that really addresses this need is https://newreleases.io . I actually spoke with the very nice husband-and-wife team behind it and even offered to buy the whole project, but their asking price was about 10× higher than what I was offering—which I understand, no hard feelings. I still wish them the best of luck.

If anyone is aware of other projects or services in this space, I'd be happy to learn about them and chat.

Github: https://github.com/tirrenotechnologies/tirreno

Live Demo: https://play.tirreno.com (admin/tirreno)

Docs: https://github.com/tirrenotechnologies/DEVELOPMENT.md

We are a 501c(3) and are actively fundraising to build a tower here in Shadow Hills and are launching our live stream and regular schedule February 1st. So far we have about 60 shows in the schedule.

If you're in Los Angeles and have an interest in radio, please hit me up.

I’m setting up the basic site, which is not a huge deal, but I’ve been inspired by more recent language designers having a streaming presence, so I am working through test runs of streaming my development.

I hope to start with demos of the basic language features and then move on to streaming both a reimplementation of my compiler and on a Rocq implementation of the syntax and semantics of the language for proof work.

The language has a rather small niche at first glance, so I’m hoping to use the streaming as a way to explore areas of appeal and maybe draw some interest. A low level concurrent and parallel ‘functional’ language with very non-traditional syntax and a modal, dependent type theory is not going to appeal to everyone, but hopefully I can find some interest eventually, even if just to hang out on chat and talk about the subject.

https://hawtads.com

If you are a brand who needs to deploy advertisements at scale, don't hesitate to reach out.

Declarative and functional in nature. Just a manifest wiring functions into a DAG and a Postgres SQL functions that manage the graph of state machines. Simple in principle and very opinionated.

Replaces 240 lines of manual pg_cron -> pgmq -> Supabase Edge Function boilerplate with 20 lines of explicit DAG definitions. Currently Supabase-only (leverages their primitives) but planning to make it agnostic for vanilla Postgres setups.

Live demo / explanation here: https://demo.pgflow.dev

- A sports club management platform, and a way for end-users to sign up for sports events, lessons etc.: https://mojtim.ba/en/

- Given the raise of AI, I'm a hiking guide and would like to have that as an alternative, an outdoor activity agency - https://boa.ba (still very WIP)

Started when I was struggling to read books in English. Pushed an open source version back then (https://github.com/baturyilmaz/wordpecker-app), later added more features, and now working on a mobile app.

Recently started testing alpha version, fixing bugs and introducing new features right now (https://alpha.wordpeckerapp.com/).

My end goal is to build: an AI language learning companion that knows what you read, listen, and watch, knows you as a friend (real life, who you are), then helps you improve using that context. If you're B1 at language, it creates a personalized path to get you to B2, then C1, and so forth using your context.

https://wordpeckerapp.com/

It's not mobile friendly yet, but maybe that'll be a next weekend project. At least you can view a video of a level on mobile.

My kids are loving it.

https://game.stackybird.com/ and the source https://github.com/jtwaleson/stacky-bird

Open Tech Calendar, listing virtual tech events that include community participation: https://opentechcalendar.co.uk/

A listings site for virtually attending FOSDEM. The live streaming is great but the official site only lists sessions in the local Brussels time zone. You can choose your time zone here: https://virtuallyattend.teacaketech.scot/fosdem/2026/

Comes with Robot, Turtle, HTML/CSS (pixel diff tasks) and a gradual introduction into programming concepts. Currently on JS, literally right now GPT-5.2 helps me adding Python.

I've integrated a simplified clone of Replicube. I hope to integrate ideas from Human Resource Machine and Turing Complete later this year.

I bear heritage of Eastern Bloc-typa math/programming olympiads, combined with front-end/product skills. So I kinda owe to ship this thing to community of fellow secondary school CS teachers.

Surprisingly, nothing comes closer in terms of depth and usability in the classroom for ordinary 12yo kids.

I test this thing 5 times a week in my classroom and I constantly polish it at night. 100% vibe-coding.

It’s absurd and will probably appeal only to the descendants of Ken Jennings.

https://slide-puzzles.specr.net

Another itch of my own to scratch but thought I'd see if I can make some side income as well.

It's a web based bookmark manager with extensions for Firefox and Chrome.

You can easily import and export bookmarks so you have all your data whenever you need.

One main thing I really like that I think makes it stand out is the ability to export the contents of a bookmarked page to an epub file to read later on your Kindle or other e-reader device.

Looking for any constructive feedback on this! Thanks.

https://patcon.github.io/polislike-human-cartography-prototy...

Just paint with colors, click a painted group, and see what differentiates your painted groups. (Chrome on iOS has issues fwiw)

This is building on the philosophy of democracy-bolstering tools like Pol.is, which I've worked with (as a researcher/practitioner) for almost a decade

[0]: https://github.com/mattrighetti/envelope/pull/46

Edit: formatting

Now working on comprehensive benchmarks for another tool I built, https://github.com/sibyllinesoft/scribe. Results thus far showing it reducing agent token usage by ~80% in real world tasks, but I need to repeat to get variance. Hopefully I can get a writeup out soon.

A browser extension (Chrome & Firefox) for simplifying my online grocery purchase workflow from Cookidoo to Knuspr.

I was tired of my weekly workflow of copying, pasting & sorting the grocery page for each item.

Also launched my first Hugo blog. Really nice experience so far. Wrote more detailed about the extension as my first blog entry: https://lars147.github.io/blog/

While the official data is technically public, it's practically inaccessible (buried in XML feeds and legacy sites).

Phase 1 was building a modern ingestion engine and freeing the information to make it more accessible. The goal is to make legislative data as accessible as sports stats.

I'm almost ready to launch the MVP; I'm just doing some bugfixes and testing the database now! (If you want an early look at the MVP, my email is in my profile.)

The next phase is what I'm most excited about: visualizing this data and using LLMs to provide insights.

With Codebox, you can define workspace templates or load workspace configurations directly from Git repositories. At the moment, it supports Dev Containers and Docker Compose, with plans to expand to additional configuration methods in the future (for example, Terraform).

Below are some resources where you can learn more about the project, including an article that explains how Codebox works and the source repositories (mirrored on both GitHub and GitLab):

* Medium article: https://medium.com/@dadebianchi2003/introducing-codebox-an-o... * GitHub repository: https://github.com/davidebianchi03/codebox * GitLab repository: https://gitlab.com/codebox4073715/codebox

Double TAP is lightweight testing framework where users write black box tests as rules checking output from tested "boxes". Boxes could be anything from http client, web server to messages in syslog. This universal approach allows to test anything with just dropping text rules describing system behavior in black box manner.

http://doubletap.sparrowhub.io/

I've been working on this for several weeks/months and I'm happy with the result!

Vibe coded it as my programming skills have eroded with time (or they never existed).

I would really appreciate some feedback.

A beginner-friendly programming language for 2D games where multiplayer is automatic. Intended to be an engaging way for teenagers to learn to code by making games they can play with their friends. Like a blend of Scratch and Roblox. I've been working on this for 3 years!

I found that sometimes I would rather interact with a chat interface to debug an issue or brainstorm architecture solutions in my repos. Agents are great for giving the model access to everything and letting it figure it out.

By manually prompting, it forces me to keep my metal model of the codebase up to date, and it allows me to provide just the context I want to the LLM.

[1]: https://github.com/haideralsh/prompt-lab

Recently, I've been very motivated to make one niche crafted service after another. For myself, family and friends. But struggled to find a compelling hosting solution for projects that only has and will have only a single user for years. I bought the cheapest mac mini M4 on sale, put it in basement and started working on some cli+daemon to help me automate all things around it. The biggest risk is security, so probably gonna rely a lot on Cloudflare at start.

Just released v0.12.0 which has a lot of package cleanup and some important bugfixes. Next, is making the relay infrastructure much more lighter, requiring less synchronization.

Personally, I'm using the hosted version[0] (which is just a repackage of the open source version with dynamic with tokens) to expose my NAS and syncthing web UIs to manage them while I'm away. Sometimes even through my phone (with termux)

[1] https://connet.dev

Main workload is done by the backend (serverless functions).

I am currently working on a HubSpot extension (that uses same backend) with the goal to target few other platforms where users work, and integrate the functionality into their daily workload, as opposed to having it as standalone website or mobile app. I have fun doing it.

Repo: https://github.com/xvandervort/graphoid

Claude Code is doing the majority of the coding, with close supervision from me. I write notes while I'm working on it. Notes are here: https://www.patreon.com/cw/aiconfessions

Building this for personal trainers with home gyms and small 1-2 location owner-operated facilities. The big players (Mindbody, etc.) are overkill and expensive for this market.

Core features: class scheduling, member booking, Stripe payments, and workout programming (the part most gym software ignores - trainers still use spreadsheets or generic apps).

Stack: React 19 + Vite frontend, ASP.NET Core 10 API, PostgreSQL, multi-tenant architecture so each gym gets their own branded experience.

Currently polishing the member dashboard and workout tracking UI. The goal is something a solo trainer can set up in an afternoon without needing to call sales or sit through demos.

OpenRailwayMap is a project focused on displaying everything railway related in the world, powered by OpenStreetMap data.

Since the last time I posted on HN it's gained a decent amount of traffic and users. I'm particularly happy with the jobs section, which is growing into a high signal-noise source for European tech jobs: https://techposts.eu/jobs

The reason I started this website is because so much incredible innovation and growth in Europe flies under the radar. If you ask Americans many will say it's just "banks and museums", stagnant, or worse. But the reality is there is a huge spectrum of exciting companies starting and growing here. We have space launch companies, battery companies, AI companies, and a whole bunch of other interesting stuff. It's an exciting time to be a European in tech!

https://requestfx.com

Would love feedback from other WFH folks — a weird amount of my productivity comes down to how I start the day.

I spent a day over break building a better UX for reviewing coding agent plans.

Plannotator - Annotate and review coding agent plans visually, share with your team, send feedback to the agents with one click.

Demo video: https://www.youtube.com/watch?v=a_AT7cEN_9I

https://github.com/backnotprop/plannotator

Despite being intensely technical and detail-oriented, certifying construction is still mostly done by hand over email!

Our niche is full of folks whose lives we can improve with a portal for document management & comms, plus a sprinkle of AI for document understanding.

If you know someone - anyone - wrangling too many documents via email. Please reach out.

https://approviq.com

I'm sure there are a ton of other projects out there that do this, but I couldn't find one that fit my needs exactly, so I threw this together in a few hours.

claude-image-renamer uses Claude Code CLI to analyze screenshots and rename them to something actually usable. It combines OCR text extraction with Claude's vision capabilities, so instead of "Screenshot 2025-12-29 at 10.03.10 PM.png" you get something like "vscode_python_debug_settings.png".

A few things it does:

    Handles those annoying macOS screenshot filenames with weird Unicode characters
    Uses OCR to give Claude more context for better naming
    Keeps filenames clean (lowercase, underscores, max 64 chars)
    Handles naming conflicts automatically

GitHub: https://github.com/jftuga/claude-image-renamer

https://workingbalm.com

I wanted something more useful to carry than typical gooey lips balm full of petroleum and silicone.

Currently it's fully-conformant to v2.0 of the spec, while I'm working towards implementing the recently released 3.0 version.

https://github.com/agis/wadec

It is similar to Meta's COCONUT. However, instead of the training forward and backwards passes of the reasoning tokens being done serially (slow), they are done in parallel (fast). At inference the reasoning tokens are still decoded serially. The trick is that even though training was done in parallel, the reasoning tokens are still causal and you still get the benefits of increased computational circuit depth.

The kicker is that the architecture is modality agnostic (it doesn't rely on language for its chains of thought), and I want to use it to bring COT reasoning to protein and anti-body generation. Basically, I hope for it to be the OpenAI o1 or DeepSeek R1 for domain-specialized scientific AI.

Even that "modern" printing stack in Linux is 20+ years old, there's still such an unbelievable amount of basic bugs and low-hanging-fruit optimizations, that it's kinda sad.

Not to mention that it still maintains ALL its legacy compatibility, as in supporting ≈5 different driver architectures, 4 user-selectable rasterizers (each with its own bugs and quirks).

The whole printing stack is supported by 4 people, 2 of whom are doing that since the inception of CUPS in 1999. Scanning is maintained by a single person.

Ubuntu 26.04 LTS is expected to be the last version with CUPS v2. CUPS v3 drops current printer driver architecture and introduces proper modern driverless printing with the wrapper for older drivers. Many open-source drivers are already use this wrapper, but expect a huge disarrangement from the users, as none of the proprietary drivers would work out of the box anymore.

Do you care about printing? Want to improve printing & scanning stack? Contact OpenPrinting! https://github.com/OpenPrinting/

You can see what it looks like right now here: https://x.com/simonsarris/status/2010359423806615907

It is based on a garden designer I made for myself to keep track of my rose garden (I have over 100 roses) and orchard (I have about 15 trees): https://garden.simonsarris.com/

However, my version was very specific to my needs, so this general version requires a lot more work to get it usable for a lot of people.

Short and sufficient version here: https://doi.org/10.5281/zenodo.17288906

Extended version here: https://go.expinent.com/VlChn65

For the past month I’ve been working on a creative / VFX / 3D tool that connects Apple devices into an all-in one node editor: https://subjectivedesigner.com/

With it, you can build interactive experiences, connect device sensors, compose shaders with AI models, orchestrate real-time data flows, and create projects that span across the entire Apple ecosystem. I’m posting about it regularly on social media and you can see some of it here: https://x.com/sxpstudio (Though it’s still early and most content is on socials thus far).

It’s done fully in SwiftUI + metal and also a good occasion to ramp up on agentic-powered software engineering. So far it’s been a lot of fun and working really great for me. And to be clear I’m absolutely not talking about vibe coding :-)

https://unrav.io

https://github.com/otsaloma/news-rss

[0] https://www.openapis.org/arazzo-specification

Similar to Cameo but hyper specialised for league of legend streamers, if this shows some traction we'll expand to other games, and then to other industries (think a tennis star reviews one of your tennis points, beats out a generic happy birthday message?)

You connect GitHub, CI, Sentry, and Linear, and it takes tickets all the way to production. Claude writes the changes, BacklogAI handles tests, migrations, feature flags, staged rollouts, etc...

It’s clearing months of backlog work in hours, and a couple teams I’m working with have already stopped hiring because it’s cheaper than adding more developers. It's crystal clear that developers and designers won't be needed in a couple of months because claude increases productivity by at least 120x and one or two PMs can do pretty much everything.

My stack is Claude, v0, nextjs, shadcn, clerk, supabase, vercel.

Instead of filtering commands with heuristics (which agents work around), it dry-runs entire scripts in a PyPy sandbox, captures every command and file operation, then shows you exactly what will happen before anything executes.

I’ve just added checkpoint/rollback so you can undo changes if something goes wrong. Currently working on example scripts for common sysadmin tasks (nginx config, log cleanup, cert audits, etc.)

https://github.com/corv89/shannot

Started this incarnation on Dec 30, 2025 -- but it's the crystallization of decades of earlier prototypes, all the way back to my Commodore-64 Logo Adventure. Built on top of Anthropic's Skills framework, extended with seven innovations (and counting):

1. Instantiation -- Skills as prototypes creating instances with their own state

2. K-lines -- Names as semantic activation vectors (Minsky's Society of Mind)

3. Empathic Templates -- Smart generation based on semantic understanding, not string substitution

4. Three-Tier Persistence -- Platform (ephemeral) → Narrative (append) → State (edit)

5. Speed of Light -- Many turns in one call, minimal tokenization overhead

6. CARD.yml -- Machine-readable skill interfaces with advertisements

7. Ethical Framing -- Room-based inheritance of performance context

Lineage: Colossal Cave → TinyMUD → LambdaMOO (filesystem as world). Papert's Logo and constructionism (learnable microworlds). Will Wright's SimCity and The Sims (I worked on the originals) -- the "Simulator Effect" where players imagine more than you simulate, and the SimAntics visual behavior programming language.

YAML Jazz: Comments aren't ignored -- they're semantic. The LLM reads and interprets them. A comment like "# gentle but firm" on a character trait actually affects behavior. This inverts the traditional "comments are for humans" assumption. Comments become part of the program and data.

The core idea: instead of prompt engineering, you give the LLM a github repo filesystem to inhabit: a persistent microworld. Seymour Papert's Constructionist philosophy comes alive, with Minsky's K-Lines pulling the strings. Skills are programs (not documentation). Characters have persistent state in directories, and can reflect on and edit themselves. Everything is inspectable and editable by human AND model. Model and platform independent. Runs on Cursor and other tools and orchestrators.

The proof is in adventure-4 -- a complete text adventure with 150+ files, 6000+ lines of session transcripts.

Repo: https://github.com/SimHacker/moollm

MOOLLM Manifesto: https://github.com/SimHacker/moollm/blob/main/designs/MOOLLM...

The MOOLLM Eval Incarnate Framework: https://github.com/SimHacker/moollm/blob/main/designs/MOOLLM...

Adventure 4 Example: https://github.com/SimHacker/moollm/tree/main/examples/adven...

My sessions as proof it works: https://github.com/SimHacker/moollm/tree/main/examples/adven...

79 Anthropic Skills (standards compatible, plus extensions, intertwingled with k-lines) and growing: https://github.com/SimHacker/moollm/tree/main/skills

A guided tour through the MOOLLM skills and microworld -- Session Log: K-Line Connections Safari: https://github.com/SimHacker/moollm/blob/main/examples/adven...

Adventure Compiler Design Discussion -- Adventure Uplift Session Log: https://github.com/SimHacker/moollm/blob/main/examples/adven...

MOOLLM Kernel: https://github.com/SimHacker/moollm/tree/main/kernel

Happy to answer questions about any of the weird design decisions!

https://nthesis.ai/public/702445eb-f0e4-4730-b34f-f34eb06dd6...

Or you can do a basic text search: https://nthesis.ai/public/hn-working-on

Never published to Steam before, it’s been a fun learning process.

I'm building a newsletter called Tech Talks Weekly[1] where my readers get one email per week with all the latest Software Engineering conference talks and podcasts[1] published that week.

In January, I've released a paid tier[2] where my subscribers additionally get:

1. Access to my internal database of all the talks and podcasts since 2020 (+48,000 in total) where they can search, filter, sort, and group by title, conference/podcast, view count, date, and duration.

2. See the list of the most-watched talks over the last 7, 30, 90 days, 6 months, and 12 months based on number of views.

3. Get category-based view of new talks & podcasts by tech stack, language, and domain (Software Architecture, Backend, Frontend, Full Stack, Data, ML, DevOps, Security, Leadership and every major language & ecosystem)

[1] https://www.techtalksweekly.io/p/what-is-tech-talks-weekly [2] https://plus.techtalksweekly.io/

https://github.com/vimana-cloud/vimana

We've built a new auth platform with some new identity primitives and capability-style tokens using biscuits.

Right now, I'm trying to figure out ways to apply it and am looking into offering integrations with extremely fine-grained access control that wouldn't have it otherwise. So adding a fine-grained access layer in front of stuff like backend-for-frontend (BFF) systems, brownfield stuff with poor auth, or even OAuth stuff that just have really coarse scopes.

Are there any integrations out there that people want but the access control is bad for them? I'll build one for you!

I’ll highlight a couple:

- an “aichat” command group that enables continuing work from a session that is at full context usage, by creating a new session and injecting session lineage pointers so the agent/sub-agent can recover arbitrary full details from ancestor sessions. So no more compacting needed.

- aichat search command: TUI for rust/tantivy-powered full text search across Claude and Codex sessions. CLI/json mode for agents to search for past work.

- Tmux-cli tool + skill to enable CLI agents to interact with scripts (including other agents) running in other Tmux panes. Like Playwright for the terminal. Multiple CLI agents can collaborate/consult etc. Agent can run and interact with interactive CLI scripts.

[1] https://github.com/pchalasani/claude-code-tools

Been working on a Google-sheet backed workout tracker, which basically makes it easy for me to see what I've done or not done recently and pick the next thing to do. I'm thinking of open sourcing this soon, but need to do some "de-monolithing" first.

I'm building a small web app with an interactive tutorial and a browser-based singleplayer game that helps people learn and practice Doppelkopf. I've just released an English version:

https://doppelkopf.club/en

It's meant to be embeddable and hackable, serving as a building block for custom IDEs as opposed to being IDE-like VSCode. I felt the web IDE space was uninspired with apps built around VScode/Monaco effectively being hosted a VSCode instance with a pre-installed extension and config.json. (Aside: perhaps there's a business opportunity for VSCode-as-a-service where client apps simply bring their own config). I'm dogfooding this library in building an algo trading IDE.

Ships 2kb and smoothly handles 50+ million line files. 1 billion lines with the high-capacity extension. Also, it can function as a TUI or terminal on the web because the core implementation concerns efficiently rendering plaintext in a fixed-width grid layout.

https://varrockbank.github.io/buffee/

https://lescahiersdejeanine.fr

The program is gonna do, what I am currently doing by hand, opening files and copying function/method signatures usually, from files all over the place.

The key here is to fetch into the context window only what is needed for one-question/one-answer and no more, hence the Context Minimization. Context fetched is gonna be specified by the programmer, for example sig(function) fetches only the signature, while @function captures the whole body. sig(Struct) is gonna fetch the fields and signatures of all of it's methods. sig(Trait) similarly.

In my view, giving the A.I. more information than needed, only confuses it and accuracy degrades. It is also slower and more expensive but that's a side effect.

The project is in early stages, for the moment it calls ast-grep under the hood, but eventually, if it works as it is supposed to, I plan to move to tree-sitter queries.

If there is a similar project somewhere I would appreciate a pointer to it, but I am not interested in implementations of agents. My program does not give the A.I. a whole view of the codebase, only the necessary points specified by the programmer.

Doors lets you explore URL addressable 3D rooms that link together seamlessly via portals. The idea is that people would upload rooms to the internet (to github, S3, whatever) and connect them together to form one giant inter-connected space that would be a real trip to explore.

Right now rooms consistent of a: - Manifest JSON file that points to requisite resources and configures portals - An optional skybox - An optional background music track - A .vox file containing voxel terrain data

Here is a video I filmed on my phone of flying through a room that links back to itself: https://www.youtube.com/shorts/BCqOYTISS_k

Portals can be arbitrarily sized and everything is prefetched/loaded seamlessly in the background.

I'm nearly done - I just need to add in a very lightweight interface and give the code a bit of a spit shine (I will open source it - so I want it to look pretty)

EDIT: As an aside, I finally decided to give this whole Claude Code thing a go - I purchased a max subscription and I'm trying to write as little code as possible. I certainly wouldn't call what I'm doing "vibe-coding". I discuss a feature in plan mode (incl. how I want to implement it in high level terms) iterate on the plan 2-3 times until I'm satisfied and then let it rip. I'm both very impressed and quite frightened by the productivity boost...

Nottawa's a free macOS app for making live audioreactive visuals. I'm trying to position it as a 100% free, batteries-included alternative to Resolume and TouchDesigner.

Not a tonne of users yet, but I'm hoping to get some traction in 2026. Would love love love to hear some feedback!

https://nottawa.app/ https://x.com/joe_crozier

Working on CiteLLM, an API that extracts structured data from PDFs and returns citations for each field (page + coordinates + source snippet + confidence).

Instead of blindly trusting the LLM, you can verify every value by linking it back to its exact location in the original PDF.

There have been lots of cool technical challenges through the whole process of building this, and a very nice variety of different kinds of work.

I'm working towards using the outputs from this language to build out levels and assets for a browser-based game I've been dabbling with over the past few years.

Now I'll have to bite the bullet and start working on marketing!!!!

https://disclosure.launchbowl.com/

A little cool tech detail, I didn't want a backend or to store the information of people's reports anywhere. To get around the requirement, I made the form deterministic and populated on load from a data stream of bits (form is made from booleans or bitfields) from a decoded base-64 query parameter. A cool side-effect of this approach is I can update the query parameter in the URL in real-time as you fill out the form so if you reload it remembers your form without any local storage or cookie use!

It has AI summarize buttons (gemini-flash-lite is so fast!) along with other features I wanted. I'm almost done adding a "war mode". The user (me!) specifies a list of OSINT style x users which show up sequentially in a grid along with a ticker on the bottom of polymarket markets I've chosen. War mode is also obviously only available in dark mode...

I've never created a game before, less so a NSFW one, and I'm not sure how it's gonna go, but it is very different compared to other things I've done before. The game itself is done in Rust, compiles to WASM to be run on the web, and I've found 3 artists and one voice actress who is helping me with the art/audio stuff. So far a lot of fun, although managing a fleet (4) of contractors is less fun, although still new so a little bit of fun :)

Still experimenting with different ways to make learning easier using LLMs.

I put together Codose as a tool where you paste a link to an Exercism or LeetCode problem, and it spins up a code editor with an AI tutor that walks you through the solution step by step, with mini lessons along the way when you need them.

You can try it without signing up but I’m on the Google AI Studio free tier right now, so I’m not sure how many uses can it handle

My friendgroup has gotten increasingly concerned with the gradual enshittification of various services we depend upon, and are looking at various alternatives. In some cases there are good selfhostable options (nextcloud, mattermost/zulip), but I decided to write my own tiny PWA to cover facebook-like needs.

The goal isn't really to scale to >1000 users, just to be simple to spin up for a small group and be easy to manage. I'm hoping to run multiple instances, eg one for family, one for college friends, one for local friends, etc.

My process has been pretty ADHD though. I recently read the phrase "It doesn't have to be done, it just has to be perfect" and felt personally attacked.

It’s fully open source: https://mogami.tech

I've been buying vintage lenses to try out.

I built it because I wanted access to my music (and videos) on my phone without running a full media server like Plex or Jellyfin, and without syncing files locally. The app streams files directly over a VPN (WireGuard / Tailscale), mainly via SFTP/FTP, and plays them as-is without re-encoding or server-side indexing.

You can browse folders directly, or let it build a lightweight local index for faster artist/album browsing on larger libraries. It started as a personal tool, but I’ve been polishing it after some feedback and opened a small TestFlight beta:

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

Still early and rough in places, but it’s already replaced my own setup.

- ETL is vanilla Python - Orchestrated with Cron and SIGUSR1 - http is Nginx -> uvicorn-> FastAPI

Data lives in a CAFS indexed with Xapian and my current time to load is ~200ms

It's been A LOT of work all far. I came in with some skills and have learnt a lot along the way

It's an "italian-oriented" curated remote-jobs and remote-work community, currently ~10k subscribers across newsletter and Telegram. What began as "let's share good remote roles" is evolving into paid job postings, sponsorships, and coaching for companies and devs.

Do you know you can hire remotely in Italy?

Building a webapp to keep track of your playlists and notify you when a song disappears

https://github.com/thehappyidiot/save-my-music

Here's a walkthrough of how ALT works: https://youtu.be/m2MER0KW3yA

versionary.app

[1] https://github.com/pedropaulovc/codjiflo/

[2] https://codjiflo.vza.net

Current status: JavaScriptCore builds in the JSCOnly config and panics on start.

JSC has extensive use of uintptr_t as a carrier of pointers and that's what most of the panics are about

I train BJJ and kept hearing the same complaints from academy owners regarding attendance tracking, comms, missing payments, etc.

So I'm building a tool for student tracking with belts progression, automated payments, attendance-based promotion criteria, and a tablet check-in system.

Focusing on Spanish-speaking markets first since it's completely underserved. Currently onboarding early academies, and will market it in the US/UK soon.

I built a browser plugin called "Visionary" that overlays meaningful descriptions and context directly onto stunning pictures of the day.

I noticed that existing picture-of-the-day plugins were built over two decades ago and never evolved to harness the capabilities of modern artificial intelligence. AI can transform the picture viewing experience by distilling complex descriptions into accessible insights and providing references to explore the core concepts in the photo more deeply.

You can get a sense of how this works by visiting https://picture.learntosolveit.com

Get it for Chrome or other Stores

https://chromewebstore.google.com/detail/picture-of-the-day/...

I've been using linux for a few years now as my main/only OS, but have mainly just used Linux Mint as a sorta plug-and-play distro.

Looking to revive my 15 year old ThinkPad (1st laptop ever!) by building up from a base Void linux install. As I'm doing it I'm writing install-scripts and getting my dotfiles in order (after never really doing so for 17+ years as a programmer lol), so I can repeat the process in the future on other machines, or when I want to do a fresh re-install.

https://github.com/staydecent/void-setup

So I started to work on a side project called "Arch Ascent" for addressing these situations. It seems like it is becoming a kind of a architectural governance tool for visualizing and validating software system dependencies.

- Dependency Graph — Syncs projects from SonarQube and visualizes component dependencies using Cytoscape.js, with graph algorithms for detecting cycles (SCCs), clustering (Louvain), and computing coupling metrics

- Visions — Workspaces for exploring architectural scenarios. Each vision can have multiple versions/variations with different layouts while sharing the same definitions

- Layers — Named groupings of components (e.g., "Domain Layer", "Team Ownership", "GitLab Groups") that can be visualized as colored regions on the canvas

- References — Named sets of components defined via Tag expressions, layer membership etc.

- Statements — Architectural intent constraints that can be evaluated against the actual dependency graph, such as existence, containment, exclusion, cardinality etc.

The plan is to also incorporate Grounds, which are Intermediate stable states on the path from the current situation (ground zero) toward a vision. Each ground represents a releasable milestone that moves the architecture closer to the target vision without necessarily fulfilling all its statements. Grounds enable incremental architectural evolution with well-defined checkpoints.

Stack: Django, HTMX, Cytoscape.js, pyparsing for natural language parsing of References and Statements.

What are those? You know… open, freedom, and privacy respecting technology. Recent products are the Starlite tablet, Furilabs and Fairphone. We've been waiting for these products, well over fifteen years since the introduction of the iPhone and iPad.

We wrote our full thoughts on the subject at: https://aol.codeberg.page/eci/

Despite posting many times, we haven't been able to start a discussion here. Maybe we don't know the right key words, or posted too late in the day, not sure. But I know someone is interested in the subject because there have been three huge discussions this week about how "Linux is good enough now."

That has been true for a decade in my experience, but no one seems to be talking about the new mobile hardware available. I hope to work on bringing these efforts together.

I'm trying to solve this problem with AI agents that help interviewers to understand who actually can code and understand the code they're presenting.

A tool for bulk mass delete posts, replies, Quotes and Reposts for Threads platform.

Still adding new features

I’m not a developer by trade but I’ve been learning iOS dev for about 6 years now. It’s become my project that I just keep working at since I personally use it a lot.

The app lets you save your favorite locations, add notes to them, add photos, check weather, tag them for better organization, and archive those tags for future trips. You can also mark off locations that you’ve been to already: think breweries or a coffee shop when visiting a new city.

For the next update, I’m working on a task list functionality for each location. The idea came as a shopping list based on which stores I go to but it can work for any other context as well. This way I can get rid of my shopping list from my task apps.

In terms of weather, I’m also adding historical averages to the forecast to have some sort of context to the weather.

Also leaning more into marketing these days (hence this post) and designing a new icon with some custom art work to give the product some sort of personality. I started learning affinity design to just do it myself so I learn some design software along the way.

Anyways, if you download it, I’d love to hear some feedback. :)

I looking mainly for European market that is willing to self host your content or the model on your own servers, we will provide the technical support in doing so that and easily plugin the AI powered search or chatbot to the website.

But it is also possible to use servers provided by us to host the content and the LLM models.

What is really cool about it is that it natively capture connections between atomic ideas and evolve them. Which I believe it gets me one step closer to syntopic reading machine.

0: https://github.com/DiaaAj/a-mem-mcp

https://github.com/LevitatingBusinessMan/edward

Features:

- No Sign-Up Required

- Instant PDF download

- Live PDF Preview

- Shareable Links

- Multiple Templates (incl. Stripe-style)

- Flexible Tax Support (VAT, GST, Sales Tax, and custom tax formats with automatic calculations)

- Multi-Language (Support for 10+ languages and all major currencies)

- Mobile-Friendly

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

On holidays finished adding flexible tax support + other improvements: https://github.com/VladSez/easy-invoice-pdf/pull/163

Would love feedback, contributions, or ideas for other templates/features =)

I've live deployed an AI-constrained governance system on Ethereum mainnet - and I was hoping to share this with the community.

If this is NOT the right place.. please let me know if there is a better alternative in sharing my full repository.

https://github.com/thetaicore/tai-constitutional-architectur...

An alternative front-end / game discovery service / price tracker for GOG's catalog. Mostly manually enhancing the data from the API (90% heuristics, 10% human effort, as the total dataset isn't large enough for it to be worth doing otherwise), and offering a wider range of filters for it all.

I'm grouping all related products together for a more complete overview, and have recently added library import, where I mostly 'solved' the issue of GOG not recognizing that you own certain games if you got them as a freebie or as part of a since-delisted deluxe edition. Just now starting in on incomplete "series" listings, seeing what'd be involved with making them contain all relevant games, and then exposing that.

Cross-account, cross-region search. Need to find an IP? Easy peasy. Need to find all the cruft Todd left behind? Search "todd" and see every todd-test-server-1 and todd-alb hanging around.

I've added insights for security, ops, and cost savings – minimal right now but expanding.

Early access/MVP mode. Feedback welcome.

I'm working on a subscription-based short-form video site called NICKEL[1]. I felt gross about using YouTube but wanted to share my gaming clips, so I made my own thing. Then I thought about making it sustainable so here we are. I'll have an update to the mailing list out in a few hours, I'm "building in public."

My feature-complete deadline is April 15th and I think I'll make it. If you want to check out the UI, visit the explore[2] page. I have it setup to redirect to a public video while I work on the intended UI (a design challenge I've never tried before but we've all seen). I'm thoroughly enjoying figuring out how streaming video works and how best to optimize things.

---

[1]: https://nickel.video

[2]: https://nickel.video/explore

A transformer-based (but not LLM) chess model that plays like a human. The site right now is very rudimentary - no saving games, reviewing games, etc., just playing.

It uses three models: * A move model for what move to make * A clock model for how long to 'think' (inference takes milliseconds, the thinking time is just emulated based on the output of the clock model) * A winner model that predicts the likelihood of each game outcome (white win / black win / draw). If you've seen eval bars when watching chess games online, this isn't quite the same. It's a percentage based outcome, rather than number of centipawns advantage that the usual eval bars use.

Right now it has a model trained on 1700-1800 rating level games from Lichess. You can turn it up and down past that, but I'm working on training models on a wide variety of other rating ranges.

If you're really into computer chess, this is similar to MAIA, but with some extra models and very slightly higher move prediction accuracy compared to the published results of the MAIA-2 paper

https://helmtk.dev is a toolkit for helm chart maintainers, including a structured template language than can compile into helm templates, and a test suite tool for writing tests in javascript. Super handy I think.

https://blog.atlas9.design is about building a better software experience by solving more of the common stuff from the start: IAM, builds, API design, etc. I'm currently designing and building a Go-based framework to start.

Now working on a second tool that monitors public reports on illegal dumping, broken streetlights and more. It tracks how long the municipality takes to resolve them

Lately, I've developed an interest in local politics and started reading policy documents, following city council meetings and even lobbied for a local park. Presenting public data clearly can help shape opinions and keeps the city council accountable, especially important with the upcoming city council elections.

I'm 17. For the past 6 months, I've been diving deep into Rust to answer a question for myself: "Is Rust actually viable for complex, enterprise-grade backend architectures, or is it just hype?"

To test this, I built a full distributed e-commerce system (22 microservices, gRPC, Event-Driven) using Axum and Tokio. This is not meant as “how everyone should build”, but as an exploration of trade-offs.

Some hard lessons I learned along the way: Complexity vs. Performance: … The "Memory Shock": … (idle baseline; load benchmarks still in progress) Over-engineering: …

I'm currently squashing the final bugs…

I'd love to hear from senior folks here: …

We delivered our first 500 units last month and got positive reviews, but lots of small issues to straighten out.

[0] https://getbrighter.com/

Got tired of helping enterprises run Concourse themselves, so we productized it. We've deployed and maintained Concourse for Starbucks, Accenture, Sky UK, and others over the years—CentralCI packages that operational knowledge into a SaaS.

Why Concourse over GitHub Actions?

* fly execute lets you test pipelines locally before pushing. No more "commit and pray" * fly intercept drops you into a running container to debug failures * Resource-based triggers can monitor anything—not just git pushes * Full pipeline visualization from dev to prod in one view * Workers you actually control (no arbitrary cache limits or runner queues)

What we handle:

* Dedicated Concourse instances on high-spec hardware (Ice Lake Xeon, DDR5, NVMe) * Worker scaling without the Kubernetes complexity * SOC compliance, auditing, AWS PrivateLink for enterprise * 24/7 support from people who've been running Concourse in production for years

The pitch is simple: Concourse is the right tool for complex CI/CD, but running it is a pain. We make it not a pain.

Long term memory for dozens of AI tools, designed for power users who want more control and flexibility than native memory systems and who do not want to be locked into any one platform. You can also have the system remember your entire chat history going back years and use this information to help you better in new chats, it sometimes makes chats 10x more useful when I say something like: “Using recall tool, do 10+ calls for 1000 tokens context each to learn about my interests, strengths, curiosities, what I’ve tried in the past, what worked, what didn’t, etc and suggest a new hobby I would enjoy”.

Without long term recall, AI is a super intelligence in your hands that uses the knowledge of the world to give you generic, nearly useless advice because of how generic it is. With long term memory, you have a super-intelligence that knows YOU. This is what MemoryPlugin solves for.

Also, my iOS apps; they're free and with no ads:

- Nonoverse (link: https://apps.apple.com/us/app/nonoverse-nonogram-puzzles/id6... ), a game about nonograms (image logic puzzles), now has 200+ levels.

- Polygen (link: https://apps.apple.com/us/app/polygen-create-polygon-art/id8... ), an app for generating low poly wallpapers and digital art, recently updated for latest iOS devices.

The core idea is a visual DAG where each transformation (filter, join, aggregate, pivot) creates a view node. Nothing materializes until you need it, DuckDB executes the full chain on demand so you can build deep pipelines without copying data at each step.

Input files can be CSV/Parquet/Excel (Excel might not work great). There's a SQL editor with schema-aware autocomplete, pivot tables with drill-down to underlying rows, and sessions can be exported as files or shareable URLs (the entire pipeline gets encoded in the hash).

Sharing can be granular and you can choose not to embed the files or if files are too big they will not be embedded and the user when opening the link will have to upload the files to restore the session.

The part I find most useful: you can replay pipelines on new data. Share your January analysis, and a colleague runs the same transformations on February's data with schema validation.

Privacy-first since files never leave your browser, it's a static website actually. I will open source soon, and make it probably MIT licensed.

Also it's a WIP and so it may be buggy (there's not even images on the homepage) https://repere.ai

A mobile app for triaging GitHub notifications in seconds. Available for iOS and Android starting next week.

Anyway, I built a way to chat with the documents in this post (updates live). https://nthesis.ai/public/702445eb-f0e4-4730-b34f-f34eb06dd6...

Or you can do a basic text search: https://nthesis.ai/public/hn-working-on

https://mafia-arena.com

The only problem I have is that it's so effing expensive to run those games that I can't have a good number of games to claim to be any sort of legit benchmark. BUT so far the games that I paid out of pocket and ran are looking good and I think there is merit to this.

also had lots of fun building on top of Cloud Flare and solving some distributed systems problems while building this.

if you can help me run more games (for science!!) let me know!

https://blog.paulbiggar.com/full-optimizing-compiler-with-ai...

HackerNews with a better UI (same content)

Example: https://github.com/JaviLopezG Url: https://octocat.yups.me/ Repo: https://github.com/JaviLopezG/octocat

A one time secret tool https://iotdata.systems/apps/secret.cgi

A password generator https://iotdata.systems/apps/pass_gen.cgi

[0]: https://handle.antfu.me [1]: https://discord.com/discovery/applications/12117814899314524...

https://github.com/ebcode/SourceMinder