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/
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)
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.
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
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!
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.
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
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.
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.
It's the Survival Crafting RPG you would have played on your Apple II back in the 80's.
You can think of it as Valheim's gameplay crammed into the tile-based ui of the old Ultima games.
It has a procedurally-generated open world with towns and NPCs to talk to, all the resource gathering, mining, crafting stuff you'd expect in a modern survival game, and some good old fashioned dungeon crawling to boot.
I've been working on it off and on for the last several months. Let me know what you think!
For the past several years I would look up the day lengths and sunset times for my location and identify milestones like “first 5pm sunset”, “1 hour of daylight gained since the winter solstice”, etc. But that manual process also meant I was limited to sharing updates on just my location, and my friends only benefitted when I made a post. I wanted to make a site anyone could come to at any time to get an optimistic message and a milestone to look forward to.
Some features this has:
- Calculation of several possible optimistic headlines. No LLMs used here.
- Offers comparisons to the earliest sunset of the year and shortest day
- Careful consideration of optimistic messaging at all times of year, including after the summer solstice when daylight is being lost
- Static-only site, no ads or tracking. All calculations happen in the browser.
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.
It’s a modern way to navigate and find home care providers in Australia. We built it after working in the industry and seeing families struggle a lot with navigating the complex aged care system (at a time in their lives which is already very stressful).
It’s very early days but it has been very enjoyable to think back on all the issues and pain points we saw in our careers and build solutions around these.
Hopefully it helps some Aussies and their parents with staying in their own home, and in feeling more confident with the decisions they make through the journey.
The stack is: Nuxt for the front-end, Postgres, and FastAPI for the backend. We set up Zoho instead of Microsoft or Google Workspace and it’s been very smooth so far (and more cost effective).
One fun part of the dev work has been learning all the magic of PostGIS - if you ever have an idea that involves geospatial data or maps, go ahead and try build it with PostGIS in the db.
It's been approx. an year since we are up and running, and we helped 100+ businesses in the US and world-wide to understand the value and savings of automated route planning, and prepared tens thousands of optimized routes for companies operating from 1 to 50 vehicles. All this keeping our operational expenses low and flat, thanks to our local-first route optimization engine working in the browser, and reliance on OpenStreetMap.
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.
We delivered our first 500 units last month and got positive reviews, but lots of small issues to straighten out.
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.
This is an HID ReMapping device, things like converting keyboard input to joystick input, or adding macros to specific inputs.
The usage is:
- It has 1 USB in and 1 USB out.
- In programming mode it's a USB drive you can put LUA scripts on (or pull out log files).
- In run mode you can select a LUA script to run.
- Scripts can read incoming mouse/joystick/keyboard data and generate outgoing mouse/joystick/keyboard data or even just log events onto a CSV file.
The code is functional, I still want to polish it and add fun animations and stuff, but for now it works as described above.
This month has been mostly mired in a PCB rework and assembly in the US. Assembly with JLCPCB is too expensive for now, so I have been spending the last few weeks sourcing components in an attempt to keep costs down. I changed the PCB a bunch as well to make assembly and case design easier
While I don't really plan on selling this, I wanted to challenge myself and make it sell-able by keeping costs really low. This has been the real challenge and time sink recently.
It is fully open source, once complete I will export a parts list and Gerber files so people who wanna make one can just use those files.
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...
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
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 =)
The problem that I am repeatedly facing is that I am trying to build a home server and I keep asking chatgpt questions, but it is hard to keep all the little details in one place. The way I see it is that I can just text my assistant bot and ask it something like "hey, can you research which NAS setup would be the best for me given x and y". It will offer some setup and I would say "can you add it to the plan" and "can you plan the next steps for me?". The bot will also update the knowledgebase and version control it.
You might also want to use it for something like planning a trip to Paris, where at some point you might say "hey, given my schedule, can you squeeze a tour to top5 croissant places in the center of Paris".
The whole thing sound really vague and sounds like something solved long ago, but I cannot find solutions that will be guaranteed to stick to a very precise plan that I can review at any given moment. If you happened to know existing solutions, please let me know. I really don't want to build this thing.
I moved last year and started a bunch of DIY projects, and each one turned into a bunch of drawings on napkins and backs of receipts to figure out how much wood/material I needed to buy to avoid "one more trip to store". It tells you how much of a stock material you need, and shows you how to cut it, to minimize waste or minimize cost.
A few details
1D: works for boards, pipes, bars, etc. You enter lengths and quantities; it details the cuts onto the stock material.
2D (coming soon): will work for plywood and sheet goods and lets you see how your parts tile onto sheets.
Apparently the software engineer to woodworking pipeline is actually just a circle
It's already working, but it requires so many tweaks and adjustments that make the project hard to finish-finish.
It's controllable by an ESP32, can run automated cooling benchmarks (to find the power vs temp sweet spot) and is pretty much all made out of metal, not 3D-printed – I've learned a ton about working with metal, especially around drilling, cutting, and tapping/threading. Who knew precise drilling a solid copper block could be so tricky at times (saying this as a person who has never drilled anything except wood/concrete before)!
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.
https://github.com/iszak/jpeg2000
I wanted to learn about wavelet transforms. I also wanted to use Rust in a non-trivial capacity. Since jpeg2000 uses discrete wavelet transforms[1] and doesn't have a Rust implementation it caught my interest.
[0]: https://en.wikipedia.org/wiki/JPEG_2000
[1]: https://en.wikipedia.org/wiki/Discrete_wavelet_transform
I'm around 99% coverage of the US. Learned a lot about land records and GIS along the way.
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
TentFires is a variant of the puzzle game Camping / Tents-and-Trees, but with a huge overworld.
Creating the overworld led to some advancements in topology, which led to realizing those advancements can be used to accurately reconstruct a theoretical "metal die shape" that was used for a glyph to creation impressions in old letterpress books.
As a result, my current first application of that is to remaster and re-release the first book of the "Hardy Boys" series from 1927, "The Tower Treasure".
To do that, I've constructed a "macrogrammetry rig", which is essentially a 2d x y panning machine using 3d printer parts and stuff from my local hardware store, and a camera with a macro lens, in order to "scan" the pages of the book at the highest possible resolution I can reasonably do so at, which is currently around 6000dpi.
During the December break, I have implemented some new features: automatic stable refdes annotations, parameter assignment rules for easy part number assignment and some ERC rules. These are also important parts of the design workflow to help turn a schematic into a usable BOM and layout.
I have created a usb-uart converter board with the CH340 chip. The complete schematic was coded with Circuitscript and then imported as a netlist into kicad pcbnew to do the pcb layout. The design was produced with JLCPCB and after receiving the boards I tested them and they do work! The design files are here https://github.com/liu3hao/usb-uart-bridge. The circuitscript code file is here https://github.com/liu3hao/usb-uart-bridge/blob/main/usb_uar... and the generated pdf from the circuitscript code is here: https://raw.githubusercontent.com/liu3hao/usb-uart-bridge/re...
The motivation for creating Circuitscript is to describe schematics in terms of code rather than graphical UIs after using different CAD packages extensively (Allegro, Altium, KiCAD) for work in the past. I wanted to spend more time thinking about the schematic design itself rather than fiddling around with GUIs.
Please check it out and I look forward to your feedback, especially from electronics designers/hobbyists. Thanks!
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.
I've been super hyped about it. My main goal at first was supporting `navigation.canGoBack` and the `currententrychange` event simply so that I could implement perfect back buttons with (almost) zero edge cases. This is surprisingly very tricky with the older History API.
Today I just opened a PR with support for `entries()` and `currentEntry`: https://github.com/kcrwfrd/navigation-ponyfill/pull/33
Once that lands I'll be able to start thinking about implementing full-blown navigations with it, with cool stuff like navigation interceptors and whatnot. That would actually enable framework router implementations wholly based off the Navigation API, rather than simply patching some enhanced capabilities for use with a router based on history.pushState / history.replaceState.
I got to a pretty stable scanning flow using Gemini 3 flash.
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)
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.
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!!
It looks inside each file to see what it’s about, then suggest the right folder for you.
Everything happens on your Mac, so nothing leaves your computer. No clouds, no servers.
It works in 50 languages (including English, German, French, Spanish, Swedish) and with images (OCR and object recognition), PDFs, Microsoft Office, ePubs, text, Markdown, and many other file types.
Next, rename files based on their content (e.g. 123023dfawjher.pdf → finance_chart_fy26.pdf).
For messy folders anywhere on the Mac, Floxtop can help.
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...
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.
Currently just the cloud hosted version (https://gitncoffee.com), but plan to open-source most of it when it's more complete.
If you want to see a repo example, https://gitncoffee.com/gitncoffee/git-demo
I suspect has to do with having agentic coding assist for folks who would otherwise not have the means to develop a game, but now do.
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.
I vibe coded the book website over the holiday break - https://sector36.space/
I've been serializing chapters on Substack - https://sector36.substack.com/
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.
In my old app, I was solely tracking the streets, but it became somewhat impossible to have pretty coverage after I moved cities. And it's more fun to see global coverage anyways. Over the past couple of years, I've been getting emails for similar features that would expose city/country wide stats as well. Going to share with the users of the old app once I port its features on this one.
Still actively polishing it over the weekends, but it's very fun to see all the places I've been to on a hex-based map, combine it with my friends' data, and so on. It's been a very fun project so far.
Started as a side project but has become my full time focus since leaving a FAANG job ~6months ago
So far we've added:
- Code typing practice with any language: https://typequicker.com/code-typing-practice - SmartPractice: analyzes your history stats to find weak areas and generates exercises for them: https://typequicker.com/app/text - TargetPractice: lets you interact with any of your stats; for example, clicking on a certain bigram that you typed slowly will create a natural practice text that targets that two character sequence - TypeAnything: let you create a typing exercise about anything; AI for typing pretty much - Advanced stas: we measure every character, 2,3 charcter sequences (delay to click in ms), every word, and even breakdown speed/accuracy per finger - Real-time hand/finger indicators: show you exactly where to place your fingers to type based on standard touch typing practices - Keyboards supported: QWERTY, QWERTZ (German keyboard) ISO, British ISO (adding Dvorak and Colemak soo).
Build Enterprise-grade applications with real backends - APIs, databases, auth, and business logic. Secure, scalable, and ready to launch in minutes.
Imagine v0, Lovable, but it actually does real backend that scales. Not prototypes. Real production quality code. The philosophy is simple - Algorithms first, AI second. Opinionated code always.
AI is decent at following instructions, but bad at being consistent, reliable. Fortunately, those problems are solved by algorithms and opinionated architecture.
The codebase generated uses Elixir for backend, Svelte for frontend. It uses best practices and opinionated algorithms to consistently produce reliable code that works the first try, doesn't waste your tokens and generates exactly what you want.
You also get finer controls - drag and drop visual designer and an ERD diagram editor (if you really want to architect the backend yourself). Code export is available as well.
Edit: I got tired of AI models trying to write code that never ends up being production worthy and always required a complete re-write. I wanted to build an interface where users could "vibe code" an entire production grade app where everything end to end is taken care of - including hosting. As an avid startup fanatic myself, I love building Saas products and thought something like this would allow me to go to market faster and test the waters.
Thanks in advance for trying it out!
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
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
- https://din.tetri.net – a personal finance manager to log income and expenses and see everything in simple charts, making it easier to understand where the money goes and to follow each month more clearly.
- https://rax.tetri.net – a group expense splitter for trips, dinners and events, where you can add shared expenses and it shows exactly how much each participant owes to each person, avoiding manual settlements.
- https://vex.tetri.net – a vehicle expense tracker to keep track of fuel, maintenance, taxes and other car-related costs, giving a more realistic view of the total cost of owning a vehicle.[2]
Right now I’m still exploring which pricing model makes more sense (monthly or yearly subscription, free plan with limits, etc.), so there are no prices defined yet.
I’d really appreciate feedback from the community on:
- Whether each product’s value proposition is clear.
- Which features you consider essential in each case.
- Pricing models that you think would work best for these niches.
Combines AI review (Ollama/Claude/Gemini) with static analysis in one place.
- Multi-LLM support (can run locally with Ollama),
- static analysis,
- GitHub/GitLab webhooks.
- Developer pulse and leaderboard to gamify reviews
- LLM cost monitoring to avoid surprise bills
Nothing fancy, just something I built for my own use and decided to open source.
Feedback welcome.
The core idea is to make it easy to capture page content, highlights and images and everything will be formatted as Markdown and is easily editable in a performant little editor window.
Then from there, I’m working on multiple export services like Clipboard export and popular PKM apps like Obsidian, Roam Research, Capacities etc.
The game engine I work on (link in bio) developed a custom language for engine customization, but it never had any runtime debugging capabilities. I've been adding that over the last couple weeks.
The language compiles to a bytecode, which is what the engine runs. But the bytecode has no source information.
The easy part was getting source locations for stack traces (associating each generated bytecode with an originating source line of code).
Harder was getting scopes information for displaying function names in those stack frames, and for associating runtime variables per-scope (stack variables, globals, class fields, etc.)
Now I just need to create an expression parser for evaluating expressions at runtime based on the current scope, add breakpoints and step over/into/etc. capability to the engine, then wrap it all together in a VSCode extension.
https://web.zquestclassic.com/zscript/ (this doesn't show what I'm working on, it's just a basic web text editor to quickly test the language. can't run it from here).
* Upload a GPX file -> see the route, map and key stats.
* Store every hike, bike ride, walk, or trek in one place.
* Think of it as a “personal notebook” for families, not a leaderboard.
I built it to keep the stories of my own kids’ adventures. It’s still in early‑stage development - if you’d like to test it out or share ideas, drop me a line!
joking aside, I'm working on a mobile app side project for a client that involves camera vision/machine learning in a heavy trucking maintenance context. Very low-ego, blue collar stuff, with a blend of modern tech. That and game dev in Godot engine has brought back my passion for coding greatly that I had lost over the last several years.
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/
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.
GitHub: https://github.com/valbuild/val
Intro video: https://youtu.be/83bnYGIsm5g?si=5LN7dxnARrS4jNEx
What sets it apart is that it 1) stores content in TS / JS files 2) is a fully fledged CMs. It is designed to be nice to work with from the start a project (and the structure of your app changes all the time) -> when everyone works on individual PRs -> to the end when the project is decommissioned.
It needs no cloud APIs, no DBs nor caching. No query language to learn. No sign up to get started. It is fully TypeSafe and needs no type generation. You can rename and refactor content from you IDE. It works amazingly with Cursor and friends (local content and schema + strong typesafty + validation)
Currently reqs are: Nextjs and GitHub.
APIs are pretty stable. UI is in the process of a revamp. Will do a proper show hn some time in the near future.
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...
Here's the elevator pitch for the framework:
Its built around 3 key ideas I've dealt with inside the agent ecosystem
1. Agents become far more capable when they have access to a CLI and can create or reuse scripts, instead of relying solely on MCP.
2. Multi-agent setups are often overvalued as “expert personas” but they’re incredibly effective for managing context, A2A is the future.
3. Agents are useful for more than just writing code. They should be easy for non-engineers to create and capable of providing value in many domains beyond software development.
If that sounds interesting take a look! https://github.com/brycewcole/capsule-agents
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.
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)
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.
I printed the main pedal frame and base with PETG, and I found some M5 hardware on amazon for pretty cheap. The pedals use a hall effect sensor to measure the proximity of the pedal to the frame base. They're wired to an esp32 ADC ports and I wrote a simple USB HID device with tinyusb and esp-idf which mounts as a generic game controller - good enough for my case. I saw some designs for a load cell brake pedal, but I wanted to do it as cheaply as possible first, so I found a stiff spring. Big inspiration was cncdan's design.
They feel great - I borrowed some old logitech pedals to compare the feel and these are much better! I think all in I spent ~$40 USD for the raw materials (spring, hardware, filament, hall sensors + wire, esp32) and a weekend of time.
The goal is to build an instant, feature rich but simple system.
We’re taking a local-first approach with electric as a sync engine. All interactions against our own apis are instant with optimistic updates. Making the app feel more like a native app rather than the typical web app.
Taking this approach has lead to some interesting challenges, both in technical and product areas. Some features requires third party roundtrips (summaries, labelling, embedding etc..) which breaks the "instant" system. We’re experimenting with ways to design those flows so the system still feels fast. Currently we only have one "loading" request in the entire system.
Having all data available on the client has also lead to some neat benefits. No need to compose or build your typical GET endpoints in the API. You just query the client DB directly!
If you have experience with any of: go, ts, react, local-first or early stage companies and want to be a part of the team building this, feel free to reach out (info in bio)
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.
Most recently, we added support for benchmarking and us stocks, etfs etc.
Benchmarking is an interesting topic. I am not sure why but most personal finance tools are quite bad at this. Our benchmarking tool allows you to understand how your underlying portfolio is doing, vs how your timing decisions are fairing. Portfolio comparison is done with NAV chart (nav calculation is same as what mutual funds use). And value chart in comparison with nav chart, helps you understand if your timing decisions are helping.
NOTE: you can try demo without signup, but it doesn't work in Firefox Incognito mode.
1) Addition of modules that you would want to use directly during your testing (think encoding, encryption, request / response manipulation)
2) Ability to extend the GUI of the application. This was challenging as Marasi the proxy is meant to be used as a library and the GUI is a separate application. Extensions run on the proxy and not the GUI application. Right now I've settled on having the GUI inject its specific render and update methods to handle that bridge.
You can check it out at https://marasi.app or the repo directly (https://github.com/tfkr-ae/marasi-app) but I would recommend download the latest development release as it includes a fix for the UI locking up of there is a lot of traffic going through the proxy.
Why? Because why not? I love CAD.
It's still very much in the early stages because it's just a side project for me, but, it is possible to draw lines and circles, copy or move them, delete, snap, create text, and a couple of other basic stuff.
Basically, just use it to identify artworks from a photo, then return a pre-generated AI-Audio for that artwork based on the data on their site. I put up a basic live version on my site for The National Gallery in London: https://victorsantiago.me/audioguide/national_gallery.html
(If you want to try it, you can open it on your phone and take a picture of some painting on the National Gallery Website, e.g.: https://www.nationalgallery.org.uk/paintings/vincent-van-gog... )
It was pretty fun to try it out and play with different LLMs and TTS models to generate the output. Might make a it a proper web app some time soon!
It’s absurd and will probably appeal only to the descendants of Ken Jennings.
I also wanted to use the opportunity to mostly vibe code it (I got a month free Pro from OpenAI, so heavily used Codex). I also wanted it to be hosted for free so built it around Cloudflare Pages, Workers and KV store. It’s basically a mobile-first weekly view that shows “what’s happening this week” for the whole family. I also wrote a small series about building it and it shows my LLM workflow with the guardrails using AGENTS.md etc.
Write-up here if anyone’s interested: https://michaeldugmore.com/p/family-planner-vibe-coding-rule...
Github repo here: https://github.com/mdugmore/family-planner-public
What it does:
File Explorer: Browse your project files and open them directly in your terminal/editor
Git Operations: Checkout and run any branch/tag directly on a device
Gradle Tasks: Run assembleDebug, installDebug, or custom tasks with streaming output
Logcat Viewer: Live filtering by level, tag, or search text
Activity Tracker: Monitor the current foreground activity
ADB Tools: Clear data, uninstall, manage permissions, input text, take screenshots
Visual Testing: Screenshot comparison tool to catch UI regressions
Terminal Integration: Open files in iTerm2, Terminal, Warp, etc.
https://saltserv.gumroad.com/l/adbremote
Feedback welcome—especially if you find yourself avoiding Android Studio for quick device tasks.
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.
Most software engineering interviews are a “signal crisis”. They measure recall, not real-world engineering.
I'm working on moving the evaluation from “writing code under pressure” to technical judgment via structured code review.
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.
The platform I am building allows users to launch Spark on Kubernetes in their own AWS account without adding any markup costs to the CPU/Memory on EC2 instances. For example, AWS EMR offering adds a 25% markup cost on top of the EC2 instance pricing. Databricks markup is even higher ranging anywhere from 30% to 100% markup.
To learn more, check out the docs for the project at https://docs.orchestera.com/
The idea is to avoid the cancel / resubscribe dance and make things feel fairer for people with tighter budgets.
Not sure if this is naive or practical — has anyone tried something similar?
My cousin has a large collection of CDs and the player is being built around his listening habits (listening to disk from start to finsh at home, individual tracks when on the go).
I'm building a system that reads Slack, listens to Google Meetings, user complaints, etc and gives me prompts I could feed into coding agents or planners.
Problem-to-prompt seems like a larger obstacle than coding these days, I wonder if it's solvable, and if solving it makes cheaper coding agents viable.
The core problem: there are now 45+ AI models for visual content (Kling, Sora, Veo, FLUX, Imagen, GPT-4o Image, etc.) and they each have different strengths. We aggregate them into one canvas where you can:
Generate images across 21 models and compare outputs side-by-side Convert images to video with 19 video models (Kling 2.6, Veo 3.1, Sora 2, Seedance) Use Storyboard mode to plan multi-scene videos shot-by-shot with consistent characters/assets Upscale, remove backgrounds, inpaint/outpaint — all in one workflow Main use case is e-commerce product content: lifestyle shots, 360° product reveals, unboxing videos. Upload a product image, generate variations across models, animate the best ones, export in platform-ready formats.
* Schematra https://schematra.com/ - a web "framework" written in CHICKEN scheme
* Lots of (unpublished, but will try to do so soon) eggs that spawned from building schematra & KartInsightsPro
* llm.scm (inspired by ruby's llm gem)
* imgui.scm
* aws.scm (support for core AWS services like SSM, S3, other APIs)
* umami.scm
Edit: format
- 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/
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 :)
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 :-)
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.
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.
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
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.
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.
I noticed that when trying to work with Claude Code I burned my token allocation really quickly and with parallel agents, no better. But when I looked at the other repos things felt really complex, for me at least.
I call it "contextd" and imagine it kind of like a context daemon you can always query in your repository for implementation plans, specs or code, etc. I always liked that git lived in your repo in the .git file, so I wanted this to work like that too but without 3rd party hosted databases or multi-repo pollution.
It's written in python at the moment, uses some local models and lanceDB but I might have it re-written in rust for speed :)
It managed to clear some pentesting benchmarks recently, so I'm very excited to put it through the fire against some real websites soon.
Please let me know if you have any recommendations for cool potential targets.
I always had the same problem with journaling. My best thoughts always came to me at inconvenient times like when I was on the subway or with friends.
So about a year and a half ago I hacked together a journaling solution for myself. I set up a Twilio phone number, a server to receive the messages, logged the message to a txt file, and committed it to a GitHub repo. It was extremely simple, but it worked surprisingly well for me. The friction was low enough that I actually used it every day... and I had perfectly timestamped journal entries with full version control.
Over time I wanted photos and voice notes, plus a better way to visualize everything. So I rebuilt this it into something more robust that other people can actually use.
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.
It’s text based, so it is basically an advanced editor/viewer for one long text note.
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
It started while I was studying for JLPT N4 — I wanted adaptive furigana that hides readings for kanji I already know, so I could focus on real text without constant lookups. That shaped the core architecture: level-based furigana, offline dictionary (JMDict), and custom tokenization logic with IPADic for accuracy.
Some interesting challenges have been furigana edge cases, Safari text paste quirks, and balancing offline performance with accuracy.
Yomu is live on the App Store now, and I’m writing about the problems that led me to build it on my blog: https://blog.kulman.sk/japanese-reading-problem/.
RespCode puts you back in control with 3 orchestration modes:
Compete Mode — Send your prompt to Claude, GPT-4o, DeepSeek, and Gemini simultaneously. See all 4 solutions side-by-side, compare approaches, and pick the winner. You're the judge.
Collaborate Mode — Chain models together in a refinement pipeline. DeepSeek drafts → Claude refines → GPT-4o polishes. Each model improves on the last, with full visibility into every stage.
Consensus Mode — All models generate independently, then Claude synthesizes the best parts into a merged solution. Democratic code generation.
But here's what makes it actually useful: Every piece of generated code runs instantly in real sandboxes — not simulated, not mocked. We support x86_64, ARM64, RISC-V, and ARM32 architectures. You see compilation output, runtime results, and exit codes in seconds.
Why "Human in the Loop" matters: AI models are powerful but imperfect. RespCode doesn't hide this — it exposes it. When you see GPT-4o produce clean code while Gemini's version has a bug, you learn which models excel at what. When Collaborate mode shows how Claude fixed DeepSeek's edge case, you understand the refinement process.
You're not just accepting AI output. You're supervising, comparing, and deciding. This is how I believe AI development tools should work — transparent, multi-perspective, and always keeping humans in the decision seat.
Here a detailed blog on why this could solve your coding problem - https://respcode.com/blog/why-single-model-ai-assistants-hol... Would love your feedback!
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.
It’s an open source project that basically turns your kubernetes into a developer friendly PaaS.
Just crossed 2k apps on the cloud version, no idea how many people run it locally, and thanks to a generous sponsorship from the Portainer folks, I’m able to work on it close to full time.
Trip Replay (https://tripreplay.app) - A client-side travel map animator where I successfully got the AI to implement complex D3 projections and WebCodecs logic.
Krypto Markets (https://krypto.markets) – A crypto dashboard built purely in "Agent Mode" to test how fast I could ship a data-heavy UI.
Gez.la (https://gez.la) – My old COVID-era open source virtual tour database project that I used agents to fully refactor and modernize from a legacy stack.
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)
https://soatok.blog/2025/10/15/the-dreamseekers-vision-of-to...
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.
# -- Not related to the thread, but if anyone is looking to hire a developer or knows of opportunities, I was recently let go and am actively searching. Any leads or feedback would be greatly appreciated.
# Reference CV : https://docs.google.com/document/d/13yYXN_QM-JmGewx9DWC765pp...
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.
Use Case: Assumption: You have access to your friends visitor parking login in Amsterdam.
You are going to a restaurant/or visiting a place near their parking zone(geo fenced polygon). You want to pinpoint a point in map and drive to that point. Being 100% sure that you can park at that point. Automatically pick a meter near there spot and park almost instantaneously. Then this app is for you :D
Update: Recently updated for this to work with new APIs and in the process updated the UI as well(slightly modern)
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).
It’s called Zadan (https://zadan.app), named after the Slavic word zadaniye (“assignment”). The goal is to keep it free and focused on getting tasks done, with only a few practical extras like file or image attachments for context which I am working on now.
I’ve only spent a few days on it, but it already feels solid and was even helpful for planning my wedding! Feedback welcome.
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.
Lots of work to automatically filter and process scraped footage into something that will train well.
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.
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?)
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.
I think of it as recursive transfer of human expertise into skills.
I know this is vague and probably raises more questions than it answers. I will share more once it reaches a semi autonomous working state.
I had the need for such a service back when I was working on ImprovMX.com. The checking system I had implemented back then wasn't efficient and had a few false positive.
At the time, I thought the market for such a need was very low so I didn't bother, but now that I'm working on https://getfernand.com, I realize I also need it. And with the advent of more and more products thanks to AI and the enthusiasm around tech, the market is growing, so it might be worth the effort to release it as a side project.
I took it as a challenge, on two simultaneous front: Technical, and AI.
On the technical side, the aim is to have a highly efficient script able to process millions of DNS record at the lowest time possible. I had to rewrite the script a few times and see how I could optimize it, but my tests lands me at around 500 QPS for now.
I'm testing against Cloudflare's DNS, and I know they have a limit at 1500 QPS, so I can't go much higher (per server), but once I reach that limit, I'll grow horizontally.
For the AI side, my approach was as follow: Use a standard web framework (Sanic in my case), build the API with a proper database structure, and once I'm satisfied with it, ask Claude code to write the OpenAPISpec file.
Once I had it, I used Mintlify to write the doc for this, and the help of Claude to have nicely written guides (rate limit, authentication, etc). Then, I asked Claude to generate the landing page, and the dashboard system.
So, except for the API and the core of the service, the other parts was mostly written in AI (I fixed some issues, improved the code Claude gave me, but that's all).
Less than three weeks after, the service is almost ready to go live. I still need to clean the code in the Dashboard part, and finalize the touches on the API server, but it can be used already (and it's used by us at Fernand).
Feel free to share your comments :)
Now I've been piecing together a complete desktop environment using niri and many other tools. If you're using Arch, you can opt-in to turn this feature on. There's an install script which can be run on a new system or existing system, documentation on each package and more at https://github.com/nickjj/dotfiles. I'm using it on 2 systems at the moment.
If you love reading, want to have an easy way to access your collection, and share it with a few people, this is for you.
https://github.com/colibri-hq/colibri
I’m looking for contributors who would like to help shape Colibri into a counter-approach to big tech; it’s specifically meant to never get monetised, and explore what such software can become.
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!
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)
The site offers a mix of nostalgic titles and new casual games that people can play instantly in any browser without downloads, whether on school/work networks or on personal devices. I’ve been focusing on polish, responsiveness, and a fun vibe, and I’m interested in seeing how players engage with different genres (from puzzle to platformers) directly in the browser.
Would love to hear feedback on the idea and potential features people want to see next.
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
Finally, we decided to open source the exe.dev agent, Shelley. https://github.com/boldsoftware/shelley
Got frustrated with Apple's Fitness app being too basic and third-party apps creating anxiety with made-up "recovery scores." Wanted something in between: proper training load tracking without the daily judgment.
Uses 42-day EWMA for chronic load, 7-day for acute. HR-based rather than rTSS since most people don't know their lactate threshold. Zone breakdowns, route comparisons, the stuff that actually helps you see if your training is working.
Free, no ads: https://apps.apple.com/app/id6749277384
Would love feedback from anyone who trains with an Apple Watch.
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!
Now I am trying to use that model to make:
1. A post game instant replay that shows the most important/pivotal moments from the most recently finished game. Some arcades have a seperate display for observers, it could work well there, or as good filler between matches on twitch streams.
2. A personalized per tournament/yearly highlights recap.
If it works well, it might be a kind of tool that generalizes well for summarizing long twitch streams for Youtube.
It helped me stay more consistent with IF - added visual indicator of previous fasts in a little calendar widget on the dashboard so every time I open it, I see my streak visually, which has been a great motivator to continue.
I also added a BMI calculator, as the NHS one I had to enter all my values from scratch each time I went, so got a bit annoyed :)
I think I'm still the only user, but it's given me a lot of value as I beat my plateau!
https://github.com/ityonemo/clr
2. Molecular biology editing software. Will plug in to agentic ai workflows
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)
I'm not sure these projects will ever "go anywhere," but at the very least I'm honing my craft as a programmer. I've learned so much, and I have so much more to learn.
---
I’m getting ready for the official launch, but while I work on expanding the library beyond the current collection of Aesop’s Fables, I’m opening up a beta.
If you’re on iOS and wouldn't mind helping me test it out, I’d love it if you had a look: https://verva.ai/en/
- connect your github and deploy from web/cli/vs code/cursor
- static sites automatically detected and deployed on a CDN
- logging
- encrypted env vars
- built in monitoring
- custom domains
- auto deployments from new branches or commits
- multi-branch deployments
In the past two months I built https://xsdviewer.com to make working with XML Schemas simpler: visual structure, navigation, diffing, and faster understanding of what actually changed between versions.
Right now I am iterating on new features and performance improvements. If you regularly work with XSDs or XML based standards and have ideas, pain points, or feature requests, I would love to hear them.
[0]: https://handle.antfu.me [1]: https://discord.com/discovery/applications/12117814899314524...
You put queries in a file `app/queries/foo.sql.erb`. Casting works and can be customised. There's ERB-support for parameterisation, with helpers like order_by and paginate.
The gem can parse and rewrite CTEs which allows for 1) rewriting the query such that basic queries (first, take, count etc.) are performant (Rails does `resultset.count`). And 2) given your query contains CTEs, it allows to write tests per CTE.
Command languages are underrated, and being able to add a Bash-like REPL for agents and users alike is something I want to see more of.
Feather solves the "rest of the Owl" problem: agents/users get loops, conditionals, online help for free from Feather, as the embedder you only need to add application-specific commands.
Feather itself has no GC (uses the host's), no own data structures (uses the host's, e.g. JavaScript arrays for lists in the js version), and no I/O.
The core is implemented in stdlib-less C
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.
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/
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.
You get tailored running schedules and also some body weight strength workouts and healthy meals all in one!
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
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)
The original dashboard was written in a hurry. It’s solid and effective, but clunky. It was written in UIKit, and uses the same backend as the main app.
The new app is being done in SwiftUI (with all its strengths and weaknesses), and has a new, streamlined, backend. It’s much faster and simpler than the original one, but will have to give up a couple of features, due to SwiftUI’s limitations (but it also adds one).
This project is also a test of LLM integration into my workflow. So far, it’s been quite helpful.
Here is a quote repository pet project that I'm having fun with: https://crucialquote.com/
And a writing prompt generator from years ago that I resurrected and still love: https://writecomfy.com/
Thanks for checking it out.
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.)
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.
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.
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/
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.
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.
Here's a walkthrough of how ALT works: https://youtu.be/m2MER0KW3yA
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.
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
The problem I’m trying to solve is how fragmented and emotional this decision usually is. Instead of blogs and anecdotes, the tool focuses on side-by-side comparisons of safety, cost of living, quality of life, visas, and taxes, so people can reason about tradeoffs more clearly.
No recommendations, no push to move. Just structured information to reduce uncertainty around a high-stakes decision. https://newlife.help
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
Recently shipped some small improvements (cache layer, email i18n), but the hardest part so far has been SEO.
This is my first time taking SEO seriously, and it’s been humbling — DR is still ~12 and trending down.
One thing I’ve found useful: comparing backlinks from Ahrefs’ free checker and Bing Webmaster Tools.
Still early, but shipping and learning steadily.
OpenRailwayMap is a project focused on displaying everything railway related in the world, powered by OpenStreetMap data.
As I've grown older, I've found myself more interested in people and their stories and motivations - especially as I know a bunch of people who are technically skilled, but feel unable or unworthy to create instead of consuming. So it's inspiring to hear really great creators talk about those same burdens and how they overcome them.
If this sparks your interest shoot me an email at bobbie @ (site above in comment)
- Prototyping a cute little SSH-based sorta-BBS, inspired by the Spring '83 protocol, but terminal-centric rather than web-based. It's called Winter '78, and if we get another Great Blizzard this year, I'll be able to make some progress on it!
- Another prototype, for an experimental HPC-ish batch system. Using distributed Erlang for the control plane, and doing a lot of the heavy lifting with systemd transient units. Very much inspired by HTCondor as well as Joyent's (RIP to a real one) Manta.
Listen to the Description. https://commercialherschel.substack.com/p/episode-000-promo-...
So far it's going well, I really need some success for better tech and comms.
The philosophy behind it is: instead of providing a bunch of tools to the LLM, you simply provide a single tool: run_python(). The Agent just generates code to do whatever it needs, to inspect local files, to carry edits, to run commands.
https://github.com/flipbit03/caducode
It worked surprisingly well, even with a very small 30b local model.
To goal is to make you write more. Tonnes of features, including posting by email (my favourite way to blog).
I love blogging and I want more people to go back to writing on their own blog and reduce time on the socials. It seems to be striking a chord with people.
Free classic plan, bargain premium plan at only $29/year.
Source available (Rails) at https://github.com/lylo/pagecord
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
Also, this Christmas I took a rest on Pulso, and I developed a small app to monitor the version & Support Lifecycle of large dependencies. https://stacktodate.club
The main idea is to reduce the friction of using multiple tools by putting everything into a single workflow. You can create visuals from text, generate background music by mood or style, and turn ideas into short videos without switching platforms.
It’s still early, but I’m actively improving the product and adding more creative features.
If you’re curious, feel free to check it out https://palix.ai/
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://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.
I always struggle to share files between my devices, or to navigate them. Why do I need servers, or dropbox or wetransfer?
Inspired by croc, rclone, syncthing and magic wormhole, I'm close to releasing KeibiDrop as MPL2.0.
It has a nice slint.dev GUI, works cross platform on mobile, + desktop (via FUSE or no-FUSE), and has post quantum encryption at transport level.
No clear monetization path, but I also tinker with unikraft in order to host a relay server (for key negotiation, or other things) as a unikernel cloud function.
https://github.com/sastrophy/siteiq
I am a student and fascinated by physics and cybersecurity. So to understand more about the field of cybersecurity and web-development, I started this project few months back. Any feedback from all of you will be really helpful in taking this project forward.
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...
I wanted to have a more difficult project and learn more about AV and Liquid Glass. I try not to vibe-code. I keep it 100% free for now, I'm looking for power users and retention. I won't monetise until I feel that this is a helpful tool.
https://apps.apple.com/us/app/kinevision-video-coaching/id67...
- https://hn-games.marcolabarile.me/
Please let me know if this looks useful to you!
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!
I often find myself losing important conversations/chats when talking to ChatGPT over time. So I created an extension that enables you to bookmark conversations within the UI. Just hover over any chat and click on the save button. Hope you find it useful.
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!
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.
Example: https://github.com/JaviLopezG Url: https://octocat.yups.me/ Repo: https://github.com/JaviLopezG/octocat
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 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.
The goal is basically what's listed on the Elm website. No runtime errors, fearless refactoring, etc. But also improved accessibility for developers who want to create a native "Linux" app. IMO Linux should be so accessible and so amenable to rapid prototyping that it is the default choice when building a new GUI app.
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:
I recently built a small experimental web app where users engage in a symbolic ritual to reflect on their digital habits. It's inspired by Eastern philosophy and aims to help people think about their time and intentions—no ads, no tracking, just reflection.
If anyone is curious, it's here: https://stillmarkapp.com
Also open-quiz-commons, the mcq dataset that powers the above quiz app: https://github.com/prahladyeri/open-quiz-commons
There’s a real-time collaborative workspace-oriented version, too.
Professionally, working on “Magic Draft,” a feature in Ditto to help designers and writers create the “draft and a half” directly in Figma, which uses a hierarchy of all your context (text, Ditto metadata, the design, your style guides, etc) to write really good starting point copy.
Stack: Bun, Next.js, SQLite, Kysely. Been building it almost entirely with Claude Code which has been a surprisingly effective workflow for this kind of infra tooling.
I’m building a platform that helps sellers manage, improve, and scale their marketplace operations from a single place, with a strong focus on time savings and decision clarity.
Current MVP: – Product listing scorecard and analysis – AI-generated product images – Product description generation (final testing phase)
Early stage, actively iterating with real sellers and shaping the roadmap based on usage and feedback.
I'm a 'vibe coder' returning to the IDE after 10 years. I spent the last 60 days managing a multi-agent stack (Codex + Antigravity) to get the perceptual color math right for P3 displays. The agents were great for the UI, but I had to manually step in when they started 'hallucinating' HEX values instead of wide-gamut OKLCH. It’s a niche tool for the Tailwind v4 ecosystem.
I've spent that last year working with news organizations to improve their online presence and a lot of my job has ended up being translating their ideas into wordpress clicks using Claude or ChatGPT. They can't take advantage of products like Lovable because the resulting code won't work with the CMS that their staff is used to.
Email me if you'd like free access! seamus@presspass.ai
Currently experimenting with semantic diffs for the merge conflicts editor: https://codeinput.com/products/merge-conflicts/demo
You can try by installing the GitHub App which will detect PRs who have a merge conflict and create a workspace for them.
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)
A one time secret tool https://iotdata.systems/apps/secret.cgi
A password generator https://iotdata.systems/apps/pass_gen.cgi
I'm expecting it is pretty niche, but animations tend to be very time consuming for people like me, and getting quick sprites that I can drop into a platform is a big time saver.
The project was 90% vibe-coded and I documented the tech stack here: https://www.8bitsmith.com/tech-stack
- 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)
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
So I added a weekly poll. I pick a stock, show some key facts, and let people vote and discuss whether it’s overvalued or a hidden gem. Takes a few minutes, usually learn something.
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.
It might be trivial for some programmers to use puppeteer or some would want to hand-build some OG images (you can mix and match), but otherwise, this tool is very handy, and set-and-forget.
I just created a Show HN for it https://news.ycombinator.com/item?id=46585378
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.
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.
Only shared it via Show HN so far, and am still regularly getting some creative submissions. Will be sharing it at an art festival later this year so kids can have a more active role when visiting.
- 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)
A bit like DraculaTheme.com
https://tomaytotomato.github.io/jensen/
https://github.com/tomaytotomato/jensen
The plan is to get a Chrome and VSCode theme shipped this week.
"I never asked for this...."
You might even say a Obsidian alternative
Free, holds your keys in localstorage and makes direct calls to the APIs (unless there's a CORS issue), at https://evvl.ai if you want to try.
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/
EDIT: It's only on iPhone and iPad for now. Android version coming soon.
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've been using it myself for a few weeks and it's helped me actually read newsletters instead of ignoring them in my inbox.
input <- old_image new_image
output -> report
Example summary:
================================================================================
TOTAL
================================================================================
-20 insns, -40 bytes (c.insn→insn +40b) [spill -22, cmov +3, call -2, br -1] mem +13, alu -6, mv -4, bitmanip -1
Added/Removed: +0 / -220 bytes
Functions: 4 better (-20 insns), 0 worse (+0 insns), 1 removed, 1062 unchangedhttps://marcelv-net.translate.goog/index.php?w=apparaat&id=3...
Short and sufficient version here: https://doi.org/10.5281/zenodo.17288906
Extended version here: https://go.expinent.com/VlChn65
Get a feel for it here: https://app.pitchwise.se/v/founder-pack
https://blog.paulbiggar.com/full-optimizing-compiler-with-ai...
A Ruby interpreter implemented in Clojure with support for GraalVM native image compilation (very initial stage, but can run some ruby code already, check out the examples directory)
Just a playground to play with Clojure and Interpreters
What I am most proud of is that I got the solution in the corse of apporx 1 week working on this!
A Ruby interpreter implemented in Clojure with support for GraalVM native image compilation (Very initial stage) but actually run some ruby code already (check examples directory)
Just a playground to play with Clojure and Interpreters
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...
Please give it a test run! I'm looking for constructive criticism on how to improve the detection thresholds and user experience.
I've spent a lot of time combing through Rightmove and Zoopla getting an idea of housing costs in different areas, now I can do it in seconds.
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.
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.
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.
I started about 3 months ago, focusing on making my 2 early adopters happy. One of them is ready to start paying soon!
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.
I have a version 1.0, and now working on how to sell and market in a crowded product space!
It's been fun to use it as I bring it to life.
A Django backend and flutter front end makes for a pretty powerful and adaptable pair.
Planning to support a self hosted version soon -- if you'd like to give it a try ping me,.
Currently it's fully-conformant to v2.0 of the spec, while I'm working towards implementing the recently released 3.0 version.
It works with your existing phone system, so you can just add AI as a line without having to replace everything…
Always wanted to create some fast paced game! Finally got to start it!
I will definitely evolve it over time.
All done in my spare time with help of agentic coding!
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.
If you are a brand who needs to deploy advertisements at scale, don't hesitate to reach out.
Recently added role sync for Saml, oidc and ldap. These auth protocols are complicated though.
Find local businesses with no websites (or check bad ones with built in SEO tools).
Build contracts, create billable invoices and track tasks for clients with a lightweight, web dev focused CRM.
Essentially, an all in one platform for web developers to find and manage their clients
Edit: formatting
Would love feedback from other WFH folks — a weird amount of my productivity comes down to how I start the day.
some features:
- no monthly subscriptions
- location via GPS/GNSS
- a screen that hangs on my fridge (akin to marauders map, to see where the cats are at all times)
- the location data stays local always.
The tech will be extended to more products - a watch for adults, kids tracker etc. Will release here once I have all the tests completed!
Managed to make long dictations even >10mins appear in < 2seconds by pushing what is possible with current STT models.
All processing done locally with 0 network calls.
It takes in your calendars and gives you time slots where you can put your head down and work! It built it for myself, but a few people found it interesting, so I thought of publishing it.
If you are someone who manages multiple calendars and multiple calls per day, then you will find this useful!
Building something is a nice break from the corporate world.
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.
I wrapped this up a while ago, but sharing because a few friends found it useful.
I wanted something more useful to carry than typical gooey lips balm full of petroleum and silicone.
As an engineer, it is hard to know when you can put your head down and work when you have multiple meetings. This helps me cure that overhead of planning my morning.
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.
I've been building it with the agent sdk and any time I want an additional skill, I create it
Examples: parse this pdf containing my credit card bill and add all transactions
Given it has a db, I've been using it to save notes, ideas etc.
Been fun
The most difficult technical challenge has been designing a pipeline to fully automate choosing test & control locations using synthetic difference-in-differences.
Attracting new monthly sponsors and people willing to buy me the occasional pizza with my crappy HTML skills.
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.
for example, RecolorLife.com and Headshoti.com generate around $800 USD.
Now I will expand for real estate.
Currently on v1, but working on v2 release in the next month.
I'm thinking of reviving my Python SQL parser prototype I have half done. Or maybe resume my Mako template plugin for PyCharm.
- WIP: A FOSS, self-hosted Luma alternative (for use across our community initiatives)
http://andeplane.github.io/ai-data-analytics
All vibe coded ofc!
[1]: https://oru.club
A mobile app for triaging GitHub notifications in seconds. Available for iOS and Android starting next week.
I'm rewriting from scratch : https://simplew.net/v26/
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.
Now I'll have to bite the bullet and start working on marketing!!!!
because I was annoyed by how managers do 1:1s or yearly reviews
Github: https://github.com/tirrenotechnologies/tirreno
Live Demo: https://play.tirreno.com (admin/tirreno)
Never published to Steam before, it’s been a fun learning process.
I am now working on a game, written in Java.
“Protein Data Bank-in-a-box”
“Protein Data Bank-in-a-Box”
An application to read Rigveda Samhita, and potentially other old indic texts in future. Inspired by University of Cologne's vedaweb.
“RSS. Nothing more, nothing less”
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
Hey all,
Looking for feedback on my site!
Feel free to roast the concept, UI, features - all fair game.
- Ben
2. Production ready AI - mix of code and human eval
3. Understanding and building for the new agentic AI commerce
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.
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.
HackerNews with a better UI (same content)
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.
- 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
The instacart button is kind of crazy. I'll casually watch videos and when something looks good, I can have the ingredients to make it delivered within the hour.
A tool for bulk mass delete posts, replies, Quotes and Reposts for Threads platform.
Still adding new features
Thought it would be a good way to learn about one form of marketing while building out some useful tools!
Looking for beta users and would love some early feedback!
The TL;DR:
- Currently in free Early Access with 18 competitive mini-games.
- Players use their mobile phones as controllers (you can use game pads as well!)
- Everything is completely web-based, no downloads or installs are necessary to play
- All games support up to 8 players at a time and are action based, with quick ~one minute rounds to keep a good pace. This means there are no language based trivia or asynchronous games!
- In the future the plan is to open up the platform for 3rd party developers (and Gamejams!) as well. We'd take care of the network connectivity, controllers etc.. 3rd party devs can focus on developing cool multiplayer mini-games without spending an eternity with networking code and building the infrastructure.
I got tired of seeing people lose their accounts to "unfollower" apps that require login credentials and use unofficial APIs. Instead, I built this to parse official Instagram GDPR data exports 100% client-side in the browser.
It’s a Vue 3 + TypeScript SPA. There is no backend; all the ZIP extraction and JSON parsing happen locally so the user’s data never leaves their machine. I even added a "Security Audit" feature to help people find suspicious login activity in their own data.
My biggest challenge right now is the UX friction. To stay safe, the user has to navigate an 11-step manual export process on Instagram to get their data. I’m trying to figure out if the "privacy/safety" benefit is enough to convince non-technical users to jump through those hoops.
Native macOS and iOS apps with OpenRouter BYOK. Same quality as in proprietary products for 1-3$ per month instead of 35$.
I am not even in school anymore, but I always dreamed of something like this when I was.
The goal was to build something as fast as a native app but with the convenience of a web link. Some of the technical bits:
* Instant Streaming: Recipients can start downloading a file the moment the first chunk leaves the sender's computer. No waiting for the full upload to finish.
* Bespoke Chunking Protocol: To handle "unlimited" file counts (tested into the millions), we group small files into larger chunks and split massive files down, so many small files and a few large files can get transferred at similar speeds.
* Auto-Resume: Both uploads and downloads automatically resume from the exact byte where they left off, even if you switch networks or close/reopen your laptop.
* E2EE via Web Crypto API: Everything is AES-GCM-256 encrypted. The secret key stays in the URL fragment (after the #), so it never gets sent to our servers.
* Zero-Knowledge Auth: We use the OPAQUE protocol for logins, meaning we can authenticate users and store their encrypted Data Encryption Keys (DEKs) without ever seeing their password or having the ability to decrypt their files.
* Passkey + PRF: We support the WebAuthn PRF extension. If your passkey supports it (like iCloud Keychain or YubiKeys), you can decrypt your account's metadata without the password.
* On-the-fly Zipping: When a recipient selects multiple files, the browser decrypts and zips them locally in real-time as they stream from our server.
* Performance: Optimized to saturate gigabit connections (up to 250 MB/s) by maintaining persistent streams and minimizing protocol overhead.
Everything is hosted in Germany (EU) for GDPR compliance. I'd love to hear any feedback on the streaming architecture or the OPAQUE implementation!
A recipe app you will actually want to use. No bloat, no ads, very minimalistic but everything works well and bugs gets fixed.
Why? Because most recipe apps and websites are frankly painful to use. I am trying to create the absolute best cooking/recipe experience possible. Something that just works.
Finding other co-founders based on proof-of-work
versionary.app
A site for filtering word lists and solving word puzzles
Anagrams, regular expression search, and a crossword helper, as well as several NYT word games.
Agents are codified for specific goals. Any business process that needs agent based assistance is broken into workflows and steps. Each step is assigned to an agent. Integrations (API or file access) is requested. Then user can try out, tweak and finally deeply.
The aim is to build a diy platform work configuration, tracing and evals in one place. Code generation is used internally. User doesn't need to write any code.
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.