Currently a one-man side project:

https://laboratory.love

Last year PlasticList discovered that 86% of food products they tested contain plastic chemicals—including 100% of baby food tested. The EU just lowered their "safe" BPA limit by 20,000x. Meanwhile, the FDA allows levels 100x higher than what Europe considers safe.

This seemed like a solvable problem.

Laboratory.love lets you crowdfund independent testing of specific products you actually buy. Think Consumer Reports meets Kickstarter, but focused on detecting endocrine disruptors in your yogurt, your kid's snacks, whatever you're curious about.

Here's how it works: Find a product (or suggest one), contribute to its testing fund, get detailed lab results when testing completes. If a product doesn't reach its funding goal within 365 days, automatic refund. All results are published openly. Laboratory.love uses the same methodology as PlasticList.org, which found plastic chemicals in everything from prenatal vitamins to ice cream. But instead of researchers choosing what to test, you do.

The bigger picture: Companies respond to market pressure. Transparency creates that pressure. When consumers have data, supply chains get cleaner.

Technical details: Laboratory.love works with ISO 17025-accredited labs, test three samples from different production lots, detect chemicals down to parts per billion. The testing protocol is public.

You can browse products, add your own, or just follow specific items you're curious about: https://laboratory.love

Repo: https://github.com/mochilang/mochi

I'm building Mochi, a small programming language with a custom VM and a focus on querying structured data (CSV, JSON, and eventually graph) in a unified and lightweight way.

It started as an experiment in writing LINQ-style queries over real datasets and grew into a full language with:

- declarative queries built into the language

- a register-based VM designed for analysis and optimization

- an intermediate representation with liveness analysis, constant folding, and dead code elimination

- static type inference, inline tests, and golden snapshot support

Example:

  type Person {
    name: string
    age: int
  }

  let people = load "people.yaml" as Person

  let adults = from p in people
             where p.age >= 18
             select { name: p.name, age: p.age }

  for a in adults {
    print(a.name, "is", a.age)
  }

  save adults to "adults.json"

Happy to chat if you're into VMs, query engines, or DSLs.

Still working on: an enclosure-compatible open-source version of the 2nd gen Nest thermostat. It reuses the enclosure, encoder ring, display, and mounts of the Nest but replaces the "thinking" part with an open-source PCB that can interact with Home Assistant.

- The encoder ring which works like an LED mouse, but in reverse: Fully reverse-engineered and on its own demo PCB

- The faceplate PCB, which does the actual control of the thermostat wires, has been laid out, but the first version missed a really-obvious problem involving the behavior on power-on with certain of the GPIO pins from the ESP32, so I've got rev 3 on order from the PCB manufacturer.

Nest Thermostats of the 1st and 2nd generation will no longer be supported by Google starting October 25, 2025. You will still be able to access temperature, mode, schedules, and settings directly on the thermostat – and existing schedules should continue to work uninterrupted. However, these thermostats will no longer receive software or security updates, will not have any Nest app or Home app controls, and Google will end support for other connected features like Home/Away Assist. It has been pretty-badly supported in Home Assistant for over a year anyway, missing important connected features.

I made a film called "Searching For Kurosawa". This short documentary chronicles the story of Kawamura, a man who worked with legendary Japanese director Akira Kurosawa on the set of his opus "Ran". Kawamura was working in the BTS crew, but his footage got confiscated. It took almost 40 years to recover the footage and present that as his feature film.

My film got screened at the Academy Award-qualifying Bali International Film Festival and the Marina Del Rey Film Festival in the past month. It will be screening next month in New York City at the Asian American International Film Festival.

I've been working on a 3D voxel-based game engine for like 10 years in my spare time. The most recent big job has been to port the world gen and editor to the GPU, which has had some pretty cute knock-on effects. The most interesting is you can hot-reload the world gen shaders and out pop your changes on the screen, like a voxel version of shadertoy. https://github.com/scallyw4g/bonsai

I also wrote a metaprogramming language which generates a lot of the editor UI for the engine. It's a bespoke C parser that supports a small subset of C++, which is exposed to the user through a 'scripting-like' language you embed directly in your source files. I wrote it as a replacement for C++ templates and in my completely unbiased opinion it is WAY better.

https://github.com/scallyw4g/poof

After 2+ years of maintaining the FOSS lightweight Reddit frontend Redlib [0], I realized that my niche but extremely detailed knowledge and experience of using Reddit's endpoints might be useful. After reverse engineering the mobile app and writing code to emulate nearly every aspect of its behavior, plus writing a codegen framework that will auto-update my code from analyzing the behavior from an Android emulator, I can pretty easily replay common user flows from any IP around the world, collecting and extracting the data. Some use cases:

* OSINT (r00m101 just beat me to it by launching...)

* Research into recommendation algorithms, advertising placement algorithms, etc

* Marketing (ad libraries, detailed analysis of content given data not even exposed to the mobile app due to some interesting side channels, things like trend analysis, etc)

* Market research for products

* Sales teams can use it to find exact mentions of other products. Eg: selling crash reporting software? Look up your target accounts' brands and find examples of complaints.

Plus a few more with more imagination.

So I'm working on a site that allows user access to some of the read-only functions available here. Coming soon :tm:. Been really fun building it all in Rust, though :) If you're interested in anything here, email in profile.

[0]: https://github.com/redlib-org/redlib

After 10 years in defense tech, watching missile attacks in Ukraine and the Middle East made it clear how little most people really get about air defense. So I'm builiding this simulator which drops you into the operator’s seat. You can test out different scenarios and build an air defense network against various types of threats (stats from real world). Also have Ukraine, Israel-Iran scenarios.

https://airdefense.dev/

I'm working on a new app for creating technical diagrams - https://vexlio.com. It's an area with some heavyweight incumbents (e.g. Visio, Lucid) but I think there's good opportunity here to differentiate in simplicity and overall experience. I'm still in the fairly early phase, and I suspect I haven't quite found the best match of features to customers yet.

From a dev perspective this area has a ton of super interesting algorithmic / math / data structure applications, and computational geometry has always been special to me. It's a lot of fun to work on.

If anyone here is interested in this as a user, I'd love for any feedback or comments, here or you can email me directly: tyler@vexlio.com.

Some pages the HN crowd might be interested in:

* https://vexlio.com/blog/making-diagrams-with-syntax-highligh... * https://vexlio.com/solutions/state-diagram-maker/ * https://vexlio.com/blog/speed-up-your-overleaf-workflow-fast...

This weekend, my modified Android/mobile Point of Sale (POS) app was used to celebrate the 100th anniversary of our village's volunteer firefighting organization.

The standard fiscal POS app was adapted to support a sort of low-trust swarm of waiters who used the app to collect orders. These orders were then transferred to a few high-trust cashiers by scanning QR codes generated on the waiters' apps.

After receiving payments, the cashiers' apps printed invoices and multiple "order tickets" categorized by "food," "drinks", "sweets"... This allowed waiters to retrieve items and deliver them to customers.

The system was used by around 40 users, with new waiters joining or leaving throughout the event. They used their own phones, and the app functioned without internet or Wi-Fi, gracefully downgraded (If a waiter didn't use the app due by choice or due to technical problems, they could manually relay orders to cashiers), Customers also had the option to approach cashiers directly, receive their order tickets, and pick up items themselves.

This is not that technically interesting, but I liked how the old manual system, the 70+ year village firefighting org. main cashier had, got digitalized in non-centralized way. (and I took this chance in trying to explain it, as I will have to, to maybe find more users for it)

I'm cleaning up a 25-30 year old bicycle. First time I've stripped one almost right back to the frame.

Strongly recommend the rust remover described by Backyard Ballistics[0] on his second channel[1]; 1 liter water, 100g citric acid, 40g washing soda, generous squirt of dish soap. He claims the acid and alkali cancel out so there's nothing to attack the normal metal surface, but they leave citrate ions which dissolve rust by chelation, which makes it better than just citric acid, vinegar, or soda alone, which all pit and dissolve the clean metal surfaces, and easier/better than wire wool scratching. He also claims it's as effective as EvapoRust but much cheaper and can do more rust dissolving per litre than EvapoRust.

[0] https://www.youtube.com/@Backyard.Ballistics - restoration of old and very rusty guns

[1] https://www.youtube.com/watch?v=fVYZmeReKKY - "The Ultimate HOMEMADE Rust Remover (Better than EvapoRust)", Beyond Ballistics channel

Ideas are coming way too fast to work on them all at the moment.

* Expect/snapshot testing library for F# is now seeing prod use but could do with more features: https://github.com/Smaug123/WoofWare.Expect

* A deterministic .NET runtime (https://github.com/Smaug123/WoofWare.PawPrint); been steaming towards `Console.WriteLine("Hello, world!")` for months, but good lord is that method complicated

* My F# source generators (https://github.com/Smaug123/WoofWare.Myriad) contain among other things a rather janky Swagger 2.0 REST client generator, but I'm currently writing a fully-compliant OpenAPI 3.0 version; it takes a .json file determining the spec, and outputs an `IMyApiClient` (or whatever) with one method per endpoint.

* Next-gen F# source generator framework (https://github.com/Smaug123/WoofWare.Whippet) is currently on the back burner; Myriad has more warts than I would like, and I think it's possible to write something much more powerful.

A few months ago I launched SpiesInDC - https://spiesindc.com, a mail-based (as in the real mail) subscription service about Cold War history. Subscribers, ahem secret agents, receive packages every few weeks containing reproductions of famous documents, stanps from the USSR, Cuba, Czechoslovakia, coins, and other fun stuff. I keep refining the packages every week to make it better and it is so much fun.

Working on a physical and digital archive of all American vintage print advertising. I've built the archival and database software on Lucee & MySQL to store images and automate, and I use OpenAI to analyze images and extra meta data. All of the full page ads are pushed to https://adretro.com.

I've gotten the process to fully catalog all of the advertisements in a magazine (about 150 on average) down from over a week to a few hours. I should be able to get through the material within my lifetime now :)

I'm finally getting my online presence in order...

This week, I'll set up a Hugo blog with the Ed theme, love it, looks exactly what I'm looking for, and as a former LaTeX enthusiast, it's pretty close. It's readable, minimalist. I'll need to customize the theme, though. I plan to publish blog posts about anything I find interesting.

https://gohugo-theme-ed.netlify.app/

In parallel to this work, I'm setting up a simple system to keep my website + subdomains easy to build, rebuild, and deploy with Caddy on a cheap Scaleway compute server. In the past, I had some ideas I wanted to publish, but the system I went with made managing the sites dreadful.

Once that's ready, I'm back to learning Rust and crypto. It's fun, interesting, challenging, remote-friendly, and the salaries are usually 30-50% better. My current tech stack feels like a dead end: it has a low ceiling in terms of salary, the projects are generally not very interesting (I'm grateful for my current project, it's the best there is with this technology), and I believe the technology will see a slow and steady decline.

Apart from work, I'm building the playground for my 2 yo son, and planting blueberries, he loves them.

I am a PhD student and for a while now I'm designing and developing a distributed network protocol that enables dynamic resource allocation across heterogeneous nodes, to which I called Rank. It's designed to handle computational, network, and temporal resources in fully distributed environments without central controllers, but that could also handle a centralized environment. Rank implements four core functions: discovery (finding paths between nodes), estimation (evaluating resource availability), allocation (reserving resources), and sharing (allowing multiple services to use the same resources). What I think it makes it unique is its ability to operate in completely decentralized environments with heterogeneous nodes, making it particularly valuable for edge computing, cloud gaming, distributed content delivery, vehicular communications, and grid computing scenarios. The protocol uses a bidding system where nodes evaluate their capability to fulfill resource requests on a scale from 0-1, enabling dynamic path selection based on current resource availability. I've implemented it in C++ and then also created a testing framework to validate its performance across different network topologies. This is still a work-in-progress and I am eager to publish results someday!

https://sewerreport.com I am a dev/sewer inspector, done over 20k inspections for real estate alone. I built the ultimate, AI report generator based on my voice to text notes. Reports, email notifications, stripe integration. Payments and invoices. Unlock reports when paid. Square appointments integrations. Pulls all appointments and fills outs new report fields for me. No copy pasting anything ever again. Very niche but saves me 3 hours a day. Next js, it’s really been life changing for me.

https://inlovingmem.com/ - is a tribute to my recently deceased mom that I vibe coded over the last week. I felt her life deserved to be celebrated widely but wanted to be sensitive to her privacy. I've also built in a number of interactive features for participation in funeral services etc, before, during, and after.

Folks have reached out about having an 'In Loving Memory Of' site for their loved ones, so I'm turning this into a side business to help out more with my (now widowed) father's retirement and care.

Not as exciting or big as some of the projects on here, but just a small personal one I’ve been wanting to do for a while.

I recently impulse bought an Epson receipt printer, and I’ve started putting together a server in Go to print a morning update every day. Getting it to print the weather, my calendar and todos, news headlines, HN front page. Basically everything I pick up my phone for in the morning, to be on paper rather than looking at a screen first thing. Very early days but hacking away and learning escpos/go! (Vibecoding a lot of it)

https://github.com/petertjmills/escpos-server

The last couple of weeks I've been building 'Recivo', a very simple way to receive emails programmatically. There are plenty of API-based services that can be used to send emails, but receiving them is harder. My service exposes a simple REST endpoint + event webhook that makes it a 5 min setup to start receiving. Attachments are included as well.

The main use-cases I'm thinking of right now is triggering agents using email or a very simple document upload flow to any SaaS (just forward an email to the SaaS).

https://recivo.email/

https://spring-agriculture.com/

Autonomous robotics for sustainable agriculture. Based in the south of the UK. Prototypes of an autonomous mechanical farm-scale weeding robot currently beginning real-world testing. Still a huge amount of work to do though.

Hardware and software developed fairly much from scratch, not using ROS (for not entirely crazy reasons...); everything written in Rust which I find well suited to this application area.

The robot is built using off-the-shelf components and 3d-printed custom parts, so build cost is surprisingly low, and iterations are fast (well, for hardware dev).

On robot compute is a couple of Raspberry Pi 5s.

Currently using the RPi AI Kit for image recognition, ie Hailo 8[L] accelerators.

Not currently using any advanced robotics VLA-type AI models, but soon looking to experiment with some of it, initially in simulation.

Feel free to get in touch if you'd like to talk :) Contact details in my HN profile, and on our website.

A homegrown Plex.

After a lot of grief trying to make Plex and jellyfish to work with my collection, and then some more with the community [1] I decided to make my own.

There's no selling point and clear pathway to monetize, as other solutions are way more mature and feature complete, but this is my own and serves my needs the best.

I've been working on it on and off for last 8 years or so, and it's been my personal benchmark for js ecosystem. The way it works, every now and then I come back to the project, look at the latest trends in js world and ask myself a simple question - what should I change in the codebase to make it online with the latest trends. And everytime it leads to full rewrite. Kind of funny, kind of sad.

In a nutshell I have a huge movie collection - basically I'm preparing for armageddon where all online streaming services cease to exist and I need both backend to fetch me detailed information about movies in the collection as well as frontend to help to decide what to watch tonight.

My next major endeavor will be trying to integrate RAG to take a bite at my holy grail - being able to ask a question like "get me a good gangster flick" and get reasonable recommendations.

[1] I think it was jellyfish where I was asking on their forums for how to manually create a collection, stating I'm a software engineer with 20+ exp and they kept telling me that I shouldn't touch the code... While having an online campaign asking for volunteers to contribute to the codebase.

I'm working on https://tickerfeed.net - a new kind of forum for stock market discussion.

After HashiCorp was acquired by IBM I decided to take time off from corporate life and build something for myself. For years I've also been a casual retail investor on the side.

Forums like /r/stocks and /r/wsb in the past have been useful resources for finding leads and interesting information. But meme-ification (among other factors) have substantially degraded sites like Reddit, to the point where interesting comments are much fewer and far in between. With TickerFeed I'm hoping to recapture what was lost - a platform where investors can discuss companies and all things stock market through meaningful long form content.

It's also a chance to build something with my dream stack - Go + HTMX + SQLite, and that's been fun :)

Working on two projects right now:

- LegalJoe: AI-powered contract reviews for startups, at the "tech demo" phase right now: https://www.legaljoe.ai/

- ClipMommy: A macOS tool to help (professionals who record a lot of videos | influencers) organize their raw video clips. Simply drag a folder of "disorganized" videos onto ClipMommy, and ClipMommy organizes the videos into folders / subfolders, adding tags, based upon some special statements that you can make at either the start or the end of your video (think audio-based "clapboard"). I'm expecting to release this within a week or two on the Mac App Store (Apple allowing...).

As an aside, I've been very impressed with Claude Code, it's (for me at least!) leading the way for how the next generation of business software might leverage AI. I plan to iterate on LegalJoe to make more "agentic" as a result of what I've seen is possible in Claude Code.

Working on RSOLV.ai - automated security vulnerability remediation. Currently a one-man shop.

The insight: Most security scanners find problems but don't fix them. Industry average time to fix critical vulnerabilities is 65+ days. We generate the actual fixes and create PRs automatically, including educational content on the nature of the vulnerability and the fix in the PR description.

Technical approach: - AST-based pattern matching (moved from regex, dropped false positives from 40% to <5%) - Multi-model AI for fix generation (Claude, GPT-4, local models) - ~170 patterns across 8 languages + framework-specific patterns; can grow this easily but need more customer validation first.

Business model experiment: Success-based pricing - only charge when fixes get merged ($15/PR at the moment). No upfront costs. This forces us to generate production-quality fixes & hopefully reduces friction for onboarding.

Early observation: Slopsquatting (AI hallucinating package names that hackers pre-register) is becoming a real attack vector. It's pretty straightforward to nail and has a lot of telltales. Building detection & mitigation for that now.

Stack: Elixir/Phoenix, TypeScript, AST parsers

https://rsolv.ai

Building https://www.typequicker.com

Long-term, passion project of mine - I'm hoping to make this the best typing platform. Just launched the MVP last month.

The core idea of the app is focusing on using natural text. I don't think typing random words (like what some other apps do) is the most effective way to improve typing.

We offer many text topics to type (trivia, literature, etc) where you type text snippets. We offer drills (to help you nail down certain key sequences). We also offer:

- Real-time visual hand/keyboard guides (helps you to not look down at keyboard) - Extremely detailed stats on bigrams, trigrams, per-finger performance, etc. - SmartPractice mode using LLMs to create personalized exercises - Topic-based practice (coding, literature, etc.)

I started this out of passion for typing. I went from 40wpm to ~120wpm (wrote about it here if you're interested: https://www.typequicker.com/blog/learn-touch-typing) and it completely changed my perspective and career trajectory. I became a better programmer and writer because I no longer had to think about the keyboard, nor look down at it.

Currently, we're doing a lot of analysis work on character frequencies and using that to constantly improve the SmartPractice feature. Also, exploring various LLM output testing/observability tools to improve the text generation features.

Approaching this project with a freemium model (have paid AI powered features; using AI to generate text that targets user weakpoints) while everything else in the app is completely free. No ads, no trackers, etc. (Hoping to have sufficient paid users so that we can run the site and never have to even think about running ads).

I've received a lot of feedback and am always looking for ways to improve the site.

I'm still working on Habitat. It's a free and open source, self-hosted platform for communities to discover their local area. The plan is for it to be federated, but that's a while off yet. I've made some good progress recently. I've added the ability to temporarily freeze user accounts, custom WYSIWYG editing for sidebar content and functionality that allows the administrator to set site-wide announcements to appear and disappear at specific dates/times. I also got some great feedback from users of my instance of it for my local town and so fixed some bugs.

- The idea: https://carlnewton.github.io/posts/location-based-social-net...

- A build update and plan: https://carlnewton.github.io/posts/building-habitat/

- The repository: https://github.com/carlnewton/habitat

- The project board: https://github.com/users/carlnewton/projects/2

I've been working on Splice CAD – an in-browser cable-harness designer.

https://splice-cad.com

Building cables for multiple personal and professional projects, I was frustrated by having to cobble together harness diagrams in Illustrator or Visio, cut snippets from from PDFs for connector outlines, map pin-outs, wire specs, cable constructions, mating terminals, and manually updating an Excel BOM.

Splice gives you:

An SVG canvas to drag-and-drop any connector or cable from your library to quickly route and bundle wires. Assign signal names to wires or cable cores.

Complete part data Connector outlines, pin-outs, terminal selections (by connector family & AWG), cable core colors & strand counts, wire AWG/color.

Automated BOM & exports parts-ready diagrams, wiring drawings, and a clean BOM in SVG, PNG, or PDF.

Connector & Cable Creators. Connectors or cables not in the existing library can be added with an optional outline and full specs (manufacturer, MPN, series, pitch, positions, IP-rating, operating temp, etc.), then publish privately or share publicly.

Demos & tutorials: Harness Builder → https://www.youtube.com/watch?v=JfQVB_iTD1I

Connector Creator → https://www.youtube.com/watch?v=zqDsCROhpy8

Cable Creator → https://www.youtube.com/watch?v=GFdQaXQxKzU

Full tutorials → https://splice-cad.com/#/tutorial/

No signup required to try—just jump in and start laying out your harness: https://splice-cad.com/#/harness. If you want to save, sign up with Google or email/password.

Just built a last-mile logistics management solution to replace a SaaS solution for a delivery company I used to be involved with.

Handles everything from real-time driver tracking, public order tracking links, finding suitable drivers for orders, batch push notifications for automatic order assignment, etc.

Backend: Feathers.JS, Postgres + TimescaleDB & PostGIS, BullMQ, Valhalla (for multi-stop route optimization although most of our deliveries are on-demand)

Frontend: SvelteKit

Mobile App (Android only for now): React Native/Expo, Zustand, Expo push notifications, and two custom native modules for secure token storage and efficient real-time GPS tracking. The tracking was probably the toughest to get right to find the best balance between battery/data efficiency and more frequent updates.

Been testing it for a couple weeks and as of last week, that company moved their operations over to it with 50+ drivers and thousands of orders processed through it so far (in a country with pretty unreliable connectivity/infrastructure).

I built it initially as a favor but open to other applications for it.

I just took a fortnight off work with the intent of getting away from my laptop, but accidentally ended up making a listings site for London's independent / arts cinemas. As far as I can tell no such thing currently exists, and I feel like it should.

Obviously the main thing is getting the listings data, which as far as I know (mostly) isn't readily available any other way that scraping the cinemas' websites, for which I set this up as a separate-ish project[1]

[0] https://filmhose.uk

[1] https://github.com/Joeboy/cinescrapers

Still on my sabbatical and continuing to build on things I enjoy rather than things that pay (for now).

Main focus is https://wheretodrink.beer, collecting and cataloging craft beer venues from around the world. No ambition of being exhaustive, but aiming for a curated and substantial list. After the last thread, a bunch of people added their suggestions, thanks! It helped add interesting new venues from cities I hadn’t covered yet.

I’m very slowly layering on features, and have a few spin-off ideas I’ll keep brewing on for later. The hardest problem thus far has been attempting to automate popularity rankings and automatic removal of defunct venues without breaching a bunch of ToS.

Also made https://drnk.beer, a small side project offering beer-related linkpages and @handles for Bluesky (AT Protocol). It's been on the backburner, but still very much live.

Probably looking for another small project for the next few months to focus on something else for a while. Always curious to see what others are building and doing. Thanks for sharing!

I am developing a utility for viewing photos directly in the terminal. The image is rendered using the ASCII character " " filling it with different colors and shades, this allows you to open the image in even on older computers.

Anyone interested can follow the link and star it on GitHub.

https://github.com/Ferki-git-creator/phono-in-terminal-image...

I'm building (and have been for the last few years) an open source high-performance Wordpress alternative on Elixir. It aims to achieve 1:1 feature parity. One thing that Wordpress has built up over the years that will take a little long for me is the plugins eco-system. But, other than that, I think everything else should be on par. IF you're an enterprise, you should easily see over 30-40% in server costs just by switching from Wordpress. This has been tested and proven with one of our enterprise clients who just recorded 500 million requests on a fork of the CMS.

But, I'm determined to see its completion even if there is just one user. I didn't take the Wordpress fiasco and how they handled it, lightly at all and it only fueled my motivation even more. ETA is by end of this year right on time for Christmas.

If you'd like to read more, here's an article about my CMS: https://medium.com/creativefoundry/what-i-learned-as-an-arti...

If you'd like to get Beta access, my email is listed in my profile.

Still working on my books site https://thegreatestbooks.org that I started in 2008. It's been a 1 man team the entire time. I recently made some major algorithm changes that I think greatly improves the rankings. My algorithm code is open source https://github.com/ssherman/weighted_list_rank

I do plan on open sourcing more of the code over time. I also have started working on other sites using the same algorithm implementation (music, movies, video games)

This has just been a side project over the year generating passive income. I get around 250,000 page views a day, and with ads, memberships, and affiliate links I make around $2,500~ a month.

Tech stack is ruby on rails 8, postgresql 17, opensearch, redis, bootstrap 5.3 hosting on 3 servers on linode.

I went Yak shaving.

For my 3D audio project I need an affordable way to make plastic cases. I felt like injection molding services are way overpriced, so I decided to make the molds in-house. Turns out, CNC milling is overpriced, too. As are 5 axis CNC mills. So in the end, we built our own CNC machine.

And like these things always go, I found an EMI issue with my power supply and a USB compliance bug in the off-the-shelf stepper control board. But it all turned out OK in the end so we now have the first mold tool that was designed and machined fully in-house. And I learned so much about tool paths and drill bits. Plus it feels like now that everyone has experienced hands-on how stuff is milled, my team got a lot better at designing things for cheap manufacturing.

* https://cijene.dev (HR, open source) - recently, Croatian retail chains were mandated to start publishing grocery prices online, but not how, so they made a mess of it; I've been building a crawler + unified API to avoid people duplicating the crawl/parse/cleanup effort (open source)

* https://trosko.hr (HR, Android/iOS app) - super-simple receipt/bill tracker (snap a photo of the receipt, reads it using Gemini, categorizes and stores locally - no accounts, no data gathering)

* https://github.com/senko/think (open source) - Python client library for LLMs (multiple providers, RAG, etc). I dislike the usual suspects (LangChain, LLamaIndex) but also don't want to tie myself to a specific provider, so chugging on my on lib for this.

I just quit my "day job" to work on a business I've built with some good friends! We make stingray-resistant booties -- ie, if you encounter stingrays in the shallows, these greatly reduce the chance you get stung (https://mydragonskin.com/). I'll be in charge of a couple marketing efforts, helping with Youtube, and other odd things that come up!

My day job required me to go into office frequently, and I'm really feeling the reduced social connection of being fully remote in a small company. Any suggestions how to deal with this? I'm planning to reconnect with old friends, surf a lot, go rock climbing, and maybe take dance / music / other classes. Would also love if anyone wants to work together in the same place (library, coffee shop, etc). I'm in Escondido California, but happy to drive ~30 min to meet folks.

I'm writing a decompiler for Turbo Pascal 3.0, to reverse engineer an educational game from the 80s.

Since TP 3.0 does no optimisations, and looking at the progress so far (~25% decompiled), it seems like matching decompilation should be achievable.

If/when I get to 100%, I hope to make the process of annotating the result (Func13_var_2_2 is hardly an informative variable name) into a community project.

I built a simple web app that helped make me more present during a family tragedy:

https://touchgrass.fm/

Brief backstory: While visiting us overseas, my in-laws were in a very bad car accident. Everyone involved is alive and going to be okay. But what followed was a series of emotional, physical and logistical challenges that pushed my wife and her parents to their limits.

During this time I found myself (shamefully) hiding on my phone. I was obsessively refreshing for updates from insurance/hospital teams, sending empty messages, and mindlessly scrolling feeds. My screen time was averaging 12 hours a day. Time I could have spent being fully present with my wife and her parents.

I finally accepted I have a serious phone addiction. I tried Apple Screen Time and a few popular screen time management apps, but found the blocks were too easy to bypass, and some apps were as useful as they were distracting depending on the context (e.g. YouTube). I didn’t necessarily want to use my phone less: it’s an incredibly useful tool, and the distractions were sometimes helpful.

What I really needed was intentional stretches of time spent away from my phone. I built touchgrass.fm as a simple way to record and incentivize those stretches of time. It’s not quite finished, but it’s been helping me stay present for hospital visits, meals and important conversations.

I am implementing a single Rust process to which you can connect a zero-knowledge proof of identity, such as can be created with ZKPassword from a physical passport. Each user ends up with a keypair which is:

1) Highly Sybil resistant. Neither the keypair owner nor anyone else can re-use the same underlying ID to link to another keypair.

2) Very high anonymity. While the Sybil resistance requires a nullifier representing the underlying ID to be present in a database (or stored in a public, decentralized form for blockchain use), there is no way to connect that nullifier with the keypair. Even if someone were to use brute force to successfully connect the nullifier with a specific underlying ID, such as a passport, there is no way to connect that ID with the keypair. (In the passport case, even merely brute-forcing the nullifier could only be done by the issuing government, someone who has hacked the government database, or someone with physical access to the passport. This is due to the fact that other passport information than the passport number is included in generating the underlying zero-knowledge proof.)

I understand that other technologies may have similar end-functionality, but this has the advantage that most of the functionality is encapsulated in a single Rust executable that could be easily used in any context, whether distributed or decentralized. (If anyone would like to know more, my contact info is at garyrobinson.net.)

I made the same little Roguelike game with Raylib in Odin, C3, and FreeBASIC over the last few weeks. [0] [1] [2]

I started on a Zig one and nope'd right on out of that after a few hours of fighting the compiler.

I'm currently working on porting a bunch of my Rust mini-games to other languages. [3]

[0] https://github.com/Syn-Nine/odin-mini-games/tree/main/2d-gam...

[1] https://github.com/Syn-Nine/c3-mini-games/tree/main/2d-games...

[2] https://github.com/Syn-Nine/freebasic-mini-games/tree/main/2...

[3] https://github.com/Syn-Nine/rust-mini-games/tree/main/2d-gam...

I've been working on a fully electric last-mile delivery company: https://hudsonshipping.co

Beyond the landing page (built with Astro), I've been building all of the route optimization, the delivery and warehouse management systems. A combination of go and java has allowed me to write a few microservices in the past 6 months to handle all of my logistical processes, and I'm just testing the mobile app in the field as we speak! I hope to make some of the code open-source one day!

I'm working on a video game called Astroloot[1], a mix of bullet-heaven and scifi-space ARPG. After two years, I've finally completed the main-campaign and now start with the endgame. Ever since playing Diablo 2, I've wanted to create an ARPG. Have to say, this project brought back the joy of programming for me.

[1] https://store.steampowered.com/app/3498390/Astroloot/

My girlfriend recently got into making sourdough and wanted to keep a log of all her recipes. She really wanted to explore the relationships between recipe water percentage and crumb density, or proof time and oven spring, for example. I built her https://sourdoughchronicle.com - a local first bread journal that allows peer to peer recipe and results sharing. Claude + aider had a MVP built in an hour and she's loving it! Oddly enough the comparison charts haven't made it in yet, but that's the next feature on the the to-do list.

Lately, I’ve been exploring a few interconnected ideas:

Local-first web applications with a compiled backend – After eight years working on web platforms, the conventional stack feels bloated. The client already defines what it wants to fetch or insert. Usually through queries. So why not parse those queries and generate the backend automatically (or at least, the parts that can be)?

Triple stores as a core abstraction – I’ve been thinking about using a triple-based model instead of traditional in-memory data structures, especially in local-first apps. Facts could power both state and logic, and make syncing a lot simpler.

Lower-level systems programming – I’ve mostly worked in high-level languages, but lately I’ve been writing C libraries (like hash maps) and built a minimal 32-bit bare-metal RISC-V OS.

It’s all still brewing, but I think these ideas tie together nicely. What if the OS didn’t have a file system and just a fact store? Everything could be queried and updated live, like a Lisp machine but built on facts.

Some other things I’ve been playing with:

A jQuery-like framework and element factory - You can pass signals that automatically updates the DOM.

A Datomic-like database on top of OPFS - where queries become signals that react to new triples as they enter the system. Pairs well with the framework above.

While taking care of my newborn, I had a lot of time to think about what annoys me most about being a software engineer. For me that is interfacing with databases.

So, I embarked a couple of weeks ago on my journey to build a relational database, which checks the boxes for me personally and I hope that this will be useful for other developers as well.

Project priorities (very early stage): - run code where the data is - inside of the database with user defined functions (most likely directly rust and wasm) - frontend to directly query the database without the risk of injection attacks (no rest, graphql, orms, models and all the boilerplate in between) - can be embedded into the application or runs as a standalone server - I hope this to be the killer feature to enable full integrations tests in milliseconds - imperative query language, which puts the developer back in control. Instead of thinking in terms of relational algebra, its centered around the idea of transforming a dataframe

Or in other words, I want to enable single developers or small teams to move fast, by giving them an opensource embeddable relational firebase.

https://reifydb.com/

If you have any thoughts on that, I would love to talk to you.

Numpad: https://numpad.io/

It's a web-based notepad calculator, which means it's a notes app but it can evaluate inline calculations like

``` £300 in USD + 20%

09:00 to 18:30 - 45 minutes ```

I wrote the core of the calculator a few years ago, and I've just launched a big rewrite that supports

* document syncing * offline editing * markdown formatting * PDF and HTML exports * autocomplete * vim mode

Happy to hear feedback :)

Been working on https://github.com/amterp/rad for almost a year now. It's a programming language designed for writing good CLI scripts, so it's aiming to replace Bash but is much more Python-like, and offers unique syntax and a bunch of in-built support for scripting.

Please check it out if it sounds at all interesting! Keen for feedback :) I've written some docs, including a "getting started" guide, linked in the GitHub page.

Lately I’ve been working on two things:

An iOS client for Cloudflare. Surprisingly, there’s none out there, maybe because nobody needs it? I do, so I’ve created one and it’s now available on TestFlight [0].

Another interesting thing I’ve recently discovered is that LLMs are pretty great at vetting tenancy agreements, so I’m working on a website that reads tenancy agreements and will return a list of unfair clauses that might be present in the contract along with a detailed explanation of how you should follow up with the landlord/agency. I still need to finish it but if you’re interested it’s here [1].

[0]: https://testflight.apple.com/join/Jj7WveWb

[1]: https://transparents.fyi

http://axcas.net is an online computer algebra system I've been working on. I'm working to finish the programming language which is based on C, and I'm adding an ode solver which I plan to use to evaluate special functions.

I release code into the public domain hoping it will be useful. There's some fast code for Groebner basis computations using the F4 algorithm (parallelized - article to follow), and some routines for machine integers e.g. discrete logarithm, factoring, and prime counting.

I've been building tooling for better debugger support for Rust types using debuginfo: https://github.com/samscott89/rudy

I'm planning on doing a proper writeup/release of this soon, but here's the short version: https://gist.github.com/samscott89/e819dcd35e387f99eb7ede156...

- Uses lldb's Python scripting extensions to register commands, and handle memory access. Talks to the Rust process over TCP.

- Supports pretty printing for custom structs + types from standard library (including Vec + HashMap).

- Some simple expression handling, like field access, array indexing, and map lookups.

- Can locate + call methods from binary.

https://github.com/srv1n/kurpod

Lets you create encrypted containers disguised as normal files. 1000s of images, pdfs, videos, secrets, keys all stuffed into an innocent look "Vacation_Summer_2024.mp4".

I've almost got true steganography working i.e to get the carrier file to actually open in any file system(currently with mp4, pdf, png and jpeg).

Things like this have existed in the past, but nothing with a simple UI,recent encryption standards.

https://DocCheetah.com - aiming to help accountants chase clients for their documentation. Launched, not got any traction, spent a little bit on advertising through LinkedIn. Probably need to execute more targeted marketing and more problem validation.

https://Full.CX - still hums along in the background. Couple of customers. Just added MCP which has been amazing to use with AI coding agents. Updating the UI/UX to ShadCN to improve usability and make it easier for future changes replacing NextUI and Daisy.

https://Toolnames.com - no changes this month.

https://Risks.io - little bit of work on the new platform, yet to be released.

https://dalehurley.com - little facelift

I am working on building a prototype for a simple 4-track recorder. It would be a cross between a Yak Back [0] voice recorder and a Tascam DP-004 [1] mixer.

My 7 year-old has gotten into music and is trying to record his own ideas. We have found the existing tools to be either too simple (Yak Back) or way too complex (Tascam). I want to make him something that has a simple interface, few buttons, and simple recording/mixing. The idea is to avoid the software programs like Garage Band and Logic.

[0] https://en.wikipedia.org/wiki/Yak_Bak

[1] https://tascam.jp/int/product/dp-004/top

I'm still working on hcker.news, which first started as a more configurable hacker news frontpage, but has turned into a thing that I've found to be quite helpful at content discovery.

I recently by request[0] added a cohesive timeline view for hn's /bestcomments. The comments are grouped by story and presented in the order that they were added to the /bestcomments page. It's a great way to see popular comments on active topics. I'm going to add other frills like sorting and filtering, but this seems to be as good a time as any to get some of your thoughts!

You can check it out here: https://hcker.news/?view=bestcomments

[0] https://news.ycombinator.com/item?id=44076987 (thx adrianwaj)

I'm working on a rhythm game for original NES: https://zeta0134.itch.io/tactus

This is written entirely in 6502 assembly, and uses a fun new mapper that helps a little bit with the music, so I can have extra channels you can actually hear on an unmodded system. It's been really fun to push the hardware in unusual ways.

Currently the first Zone of the game is rather polished, and I'm doing a big giant pixel art drawing push to produce new enemies, items, and level artwork to fill out the remainder of the game. It's coming along slowly, but steadily. I'm trying to have it in "trailer ready" / "demo" state by the end of this calendar year. Just this weekend I added new chest types and the classic Mimic enemy to spice things up.

Currently working on a project for EU region to compare supermarkets prices across certain countries it’s called https://compears.shop/nl

I'm working on LLM translation research for my tool that teaches you a language while you browse by translating sentences at your level into the language you're learning (https://nuenki.app)

I've had some breakthroughs with LLM translation, and I can now translate (slowly, unfortunately) at a far far higher quality than Opus, and well above DeepL. So I'm considering offering that as an API, though I don't know how much people actually care about translation quality.

DeepL's customers clearly don't care - their website is all about enterprise features, and they appear to get plenty of business despite their core product being mediocre.

Would people here be interested in that?

Still working on https://periplus.app, and recently started to see some traction.

It's an environment for open-ended learning with LLMs. Something like a personalized, generative Wikipedia. Has generated courses, documents, exams and flashcards.

Each document links to more documents, which are all stored in a graph you grow over time.

Building an app that extracts key information from PDFs + highlights citations. You provide a PDF and a JSON schema defining what to extract, and it returns the extracted values, the citations and their precise locations in the document.

This is especially valuable in workflows where verification of LLM extracted information is critical (e.g. legal and finance). It can handle complex layouts like multiple columns, tables and also scanned documents.

Planning to offer this both as an API and a self-hosted option for organizations with strict data privacy requirements.

Screenshot: https://superdocs.io/highlight.png

I've been building small programs in Zig, C and ARM64 assembly without relying on libc and only using Linux syscalls directly.

Some examples:

- A minimal C shell with built-ins like cd, pwd, type: https://gist.github.com/rrampage/5046b60ca2d040bcffb49ee38e8...

- Terminal Snake game which fits in a QR code using Linux syscalls for drawing: https://gist.github.com/rrampage/2a781662645dc2fcba45784eb58...

- HTTP server with sendfile support in ARM64 assembly: https://gist.github.com/rrampage/d31e75647a77badb3586ebae1e4...

I learned to handcraft a static ELF binary using just GNU assembler (no linker): https://gist.github.com/rrampage/74586d0a0a451f43b546b169d46... . Trying to see if I can craft a small assembler in ARM64

I finally compiled and expanded on all my various blog posts, tutorials and other Python goodness into a book: Working with Python. It is available as a free pdf download at: https://mkaz.blog/working-with-python/

It's grown over a dozen or so years and when I finally decide to compile into a book, everyone now uses AI and no longer read and learn from books but instead through LLMs.

Me and my friend are working on Workback[1], a tool that can fix a11y issues end-to-end.

First we built it as a tool to fix any bug. After talking to a few folks, we realized that it is too broad. From my own personal experience, we realized how messy it is within organizations to address accessibility issues. Everybody scrambles around last minute. No body loves the work - developers, PMs, TPMs etc. And often external contractors or auditors are involved.

Now with Workback, we are hoping to solve the issues using the agentic loop.

If you personally experienced this problem, would love to chat and learn from your experience.

[1] https://workback.ai

Still building. https://tosreview.org/

Reading through the Terms of service in websites is a pain. Most of the users skip reading that and click accept. The risk is that they enter into a legally binding contract with a corporation without any idea what they are getting themselves into.

How it started: I read news about Disney blocking a wrongful death lawsuit, since the victim agreed to a arbitration clause when they signed up for a disney+ trial.

I started looking into available options for services that can mitigate this and found the amazing https://tosdr.org/en project.

That project relies on the work of volunteers who have been diligently reading the TOS and providing information in understandable terms.

Light bulb moment: LLM's are good at reading and summarizing text. Why not use LLMs for the same. That's when I started building tosreview.org. I am also sending it for the bolt.new hackathon.

Existing features: Input for user entered URLs or text Translation available for 30+ languages.

Planned features: Chrome/firefox extension Structured extraction of key information ( arbitration enforced , jurisdiction enforced etc).

Let me know if you have any feedback

I'm not actively working on it daily, as I have shortage of free time and helping hands, but the HTTP Spec Test Suite is my Moby-Dick. I wrote about it here: https://www.caffeinatedwonders.com/2024/12/18/towards-valida..., I also discussed it on the HTTP WG mailing list and presented it at the HTTP WG Workshop last year.

Another Moby-Dick of mine is Kadessh, the SSH server plugin of Caddy, formerly known as caddy-ssh. This one is an itch. I wrote about it here https://www.caffeinatedwonders.com/2022/03/28/new-ssh-server..., and the repo is here: https://github.com/kadeessh/kadeessh. Similar to the other one, feedback and helping hands are sorely needed.

They are both sort of an obsession and itches of mine, but between dayjob and school, I barely have a chance to have the clear mind to give them the attention they require.

Myself.

Been a freelance dev for years, now beginning a "sabbatical" (love that word).

Planning to do a lot of learning, self-improvement, and projects. Tech-related and not. Preparing for the next volume (not chapter) of life. Refactoring, if you like, among other things.

I'm excited.

I’m building an e-book reader for the web and PWA platforms:

https://flowery.app/books

The library of public domain classics is courtesy of Standard Ebooks. I publish a book every Saturday, and refine the EPUB parser and styler whenever they choke on a book. I’m currently putting the finishing touches to endnote rendering (pop-up or margin notes depending on screen width) so that next Saturday’s publication of “The Federalist Papers” does justice to the punctilious Publius.

Obligatory landing page for the paid product:

https://flowery.app/vocabulary-building

I am working on building a custom PDF Web Component. With this web component, you can

- Create your own PDF editor with custom UI with the help of public methods which are exposed in the web component.

- You can add dynamic variables/data to the templates. What this means is you create one template, for example, a certificate template with name and date as variables and all you have to do is upload your CSV / JSON of names and dates, and it will generate the dynamic PDFs for you.

- It's framework-agnostic. You can use this library in any front-end framework.

It's still in early development, and I would love to connect with people who have some use cases around it.

I have integrated this library in one of our projects, Formester. You can see the details here https://formester.com/features/pdf-editor/

I have posted this demo video for reference https://www.youtube.com/watch?v=jorWjTOMjfs

Note: Right now it has very limited capabilities like only adding text and image elements. Will be adding more features going forward.

Working on https://vide.dev, the Cursor for Flutter devs.

While Cursor stops after writing great code, Vide goes the extra mile and has full runtime integration. Vide will go the extra mile & make sure the UI looks on point, works on all screen configurations and behaves correctly. It does this by being deeply integrated into Flutters tooling, it's able to take screenshot/ place widgets on a Figma-like canvas and even interact with everything in an isolated and reproducible environment.

I currently have a web version of the IDE live but I'm going to launch a full native desktop IDE very soon.

I'm building a platform to help people—especially students and young adults—design meaningful, intentional lives with balance, courage, and an entrepreneurial mindset.

In Singapore, the system is heavily academic. You're expected to follow a rigid path (PSLE → JC → Uni → job), but no one teaches you how to think about what kind of life you want to live—or how to create it. That leaves many people feeling lost, even if they’re “on track.”

This platform flips that. It starts with the big picture: *“When you’re 90, what do you want your life to have looked like?”*

From there, users create a personal timeline of milestones across life domains: health, relationships, learning, impact—and now, *financial freedom.*

The app helps users:

1. Set long-term visions, then break them into clear, visual milestones

2. Use an AI assistant to suggest weekly actions and recalibrate as life evolves

3. Voice journal instead of typing; the AI transcribes and flags patterns (“You mentioned burnout 5x this week. Want to add a rest week or revise your work goals?”)

4. Track basic finances and align spending/saving to long-term goals (“You want to take a year off at 30. At this pace, you’ll have the runway by 32. Want to adjust?”)

5. Get matched with mentors or peer circles for guidance and accountability

The goal is not to “optimize” life like a spreadsheet. It’s to help people reflect, take control, and become someone they’re proud of.

If you’ve worked on anything in this space—journaling, goal tracking, financial wellness, coaching—I’d love to learn:

A. What made your tool stick long-term?

B. How did you balance simplicity with depth?

C. Any design or product traps I should avoid?

Appreciate any thoughts, questions, or brutal feedback.

Mostly writing for myself; I should really convert some drafts into proper blog posts because I'm really interested in discussing my ideas with others.

I've been thinking a lot about the current field of AI research and wondering if we're asking the right questions? I've watched some videos from Yann LeCun where he highlights some of the key limitations of current approaches, but I haven't seen anyone discussing or specifying all major key pieces that are believed to be currently missing. In general I feel like there's tons of events and presentations about AI-related topics but the questions are disappointingly shallow / entry-level. So you have all these major key figures repeating the same basic talking points over and over to different audiences. Where is the deeper content? Are all the interesting conversations just happening behind closed doors inside of companies and research centers?

Recently I was watching a presentation from John Carmack where he talks about what Keen is up to, but I was a bit frustrated with where he finished. One of the key insights he mentions is that we need to be training models in real-time environments that operate independently from the agent, and the agent needs to be able to adapt. It seems like some of the work that he's doing is operating at too low of an abstraction level or that it's missing some key component for the model to reflect on what it's doing, but then there's no exploration of what that thing might be. Although maybe a presentation is the wrong place for this kind of question.

I keep thinking that we're formulating a lot of incoherent questions or failing to clearly state what key questions we are looking to answer, across multiple domains and socially.

Working on tail calls for TXR Lisp. Current release provides self tail calls only; and certain cases don't work, like applying in tail position. Plus there is a shadowing bug. These issues are addressed already.

Tail calls between different VM functions are the next challenge. I'm going to somehow have it allocate the VM instance in the same space (if the frame size of the target is larger than the source, "alloca" the difference). The arguments have to be smuggled somehow while we are reinitializing the frame in-place.

I might have a prefix instruction called tail which immediately precedes a call, apply, gcall or gapply. The vm dispatch loop will terminate when it encounters tail similarly to the end instructions. The caller will notice that a tail instruction had been executed, and then precipitate into the tail call logic which will interpret the prefixed instruction in a special way. The calling instruction has to pull out the argument values from whatever registers it refers to. They have to survive the in-place execution somehow.

I'm currently building a suite of free AI tools for the beauty niche:

https://www.nose-shapes.com Upload a selfie and an AI model classifies over a dozen nose types (Greek, button, fleshy, flat, etc.), plus tips on contouring and finding complementary glasses.

https://www.foundation-shade-finder.com Snap a photo and our AI analyzes your skin tone + undertone, then recommends exact foundation shades from brands like MAC, Fenty, L’Oréal, Estée Lauder.

https://www.golden-ratio-face.com Measures facial proportions against the "golden ratio" to reveal symmetry and aesthetic balance—perfect for beauty enthusiasts and content creators seeking visual harmony.

All of them are no‑login, instant‑result web tools. I'd love the get any feedback from accuracy and UI to feature ideas or niche extensions.

A job feed for remote jobs - https://tangerinefeed.net/

This is something I’ve needed myself over the last few years as jobs become shorter and shorter lived. Keep on improving it as some kind of compulsion.

I'm building https://prijm.com which is a minimalist link sharing and post creation platform with custom feed and notification support for your activities. Here are some of the features:

- Supports markdown every where, even in your comments and replies.

- Get notified.

- Personalized feeds.

- Lightning fast & mobile first.

I’ve been working on an app called Lång. It’s a calm daily spending guide – shows you what’s okay to spend today, based on how much needs to last how long.

The idea came from noticing how most people manage money day to day: checking their balance, adjusting by feel, trying not to drift. There are tons of tools for planning or categorising, but not much that fits that kind of improvised pacing.

Still early, but trying to shape it around those habits – to make something simple and steady, that supports how people already do things.

https://lang.money

Been working on https://www.stainedglassatlas.com.

Trying to document and map as much of the publicly accessible stained glass as possible. The goal being the next time you visit a new city or town, you'll know where all the beautiful stained glass is to go see. Just recently added support for countries outside of North America. No exciting tech (vanilla HTML/CSS/JS). But excited for folks to check it out!

I've been working on implementing @mpweiher "Storage Combinators" [0] and "polymorphic Identifiers" [1] in Eiffel [3].

Currently I'm stuck implementing a storage combinator with EiffelWebFramework[4]

[0] https://dl.acm.org/doi/abs/10.1145/3359591.3359729

[1] https://scholar.google.com/citations?view_op=view_citation&h...

[2] https://en.wikipedia.org/wiki/Eiffel_(programming_language)

[3] https://github.com/EiffelWebFramework/EWF

I'm building an app to help users find free and paid street parking in Vancouver: https://instaparkr.com/

While apps like Parkopedia and SpotAngels tackle the same problem, their one-size-fits-all approach often results in incomplete, missing, or outdated data. My approach is different: go deep on one city at a time by combining multiple publicly available datasets. This doesn't scale horizontally since each city has different data sources and formats, but the goal is to become the definitive parking resource for one city, build automation to keep it current, then methodically expand city by city.

If you are based in Vancouver, do give it a go. Your feedback would be awesome!

Hej, I made FisherLoop[1] to learn Swedish. FisherLoop are interactive audiobooks where I use TTS with word level timestamps to highlight the words as they are spoken. This helps me pick up on pronounciation and grammar in a, for me, natural way. Additionally, I added flashcards from the books + word lookup. I am adding new books right now. If you have any requests: public domain books, which are around one hour reading time let me know :)

I am using cerebras for book translations and verb extraction and all LLM related tasks. For TTS I am using cartesia. I have played around with Elevenlabs and they have slightly natural sounding TTS but their pricing is too steep for this project. Books would cost a couple of hundred euros to process.

[1] https://www.fisherloop.com/en/

I am working on an app to detect tooth problems. I envision it as something you can use for a quick check for the large majority who don't have regular dental care. It will be late detection but a good alternative to doing nothing.

I am experimenting with the current SOTA multimodal LLMs, but performance is still not yet there, they still hallucinate non-existent teeth. (As an aside, I have found a simple but very telling test, I have an image with only 4 teeth visible up and 10 down, so I prompt the modal to count, non have been able to, but Gemini 2.5 pro is the closest of the lot, performance is worse in the description when the counting test fails).

I am going to try segmenting the image to see if I will have better results by prompting to describe segment by segment.

I'm working on an MCP to give your coding agent the ability to generate on-demand Mermaid diagrams about anything in your codebase. Among other benefits, it is very helpful for spotting unnecessary code or architecture that can accumulate while vibe coding.

https://www.npmjs.com/package/@mindpilot/mcp

Claude Code Quickstart:

``` claude mcp add mindpilot -- npx @mindpilot/mcp ```

Writing SFF novels!

I need to put it up on the ol' blog-thing, but I've signed a contract with a small press for a debut novel, which is highly exciting. That one's urban fantasy from the point of view of the wizard's magic cloak. (You better believe it has opinions.)

Meanwhile, I've been working on a novel about a group of time travelers who accidentally get stuck in the Permian, well before the dinosaurs. Surprise! There are still big animals that can eat you, they're just more weird (and not as big). The research for that one has been wild.

The ol' blog thing, where I post story-related tidbits and such: https://rznicolet.com

I'm tinkering with relative positional encoding by trying to integrate acoustic features directly into it.

More specifically, I'm trying to use pitch (F0) to dynamically adjust the theta parameter in rotary positional embeddings, so the frequency of the positional encoding reflects the underlying pitch contour of the speech and instead of using a fixed unit circle (radius=1.0) for complex rotations, I'm trying to work out how to use variable radii derived from the pitch. The idea is to create acoustically-weighted positional encodings, where the position reflects the acoustic salience in the original audio. https://github.com/sine2pi/asr_model

I'm working on MedAngle, the world's first Super App for current + future doctors. An invite only platform, which has everything people in medschool/dental school and recent graduates need. From analytics, quizzes, summaries, x-rays , videos to tens of thousands of questions, ~100k+ students/doctors have solved over 100m questions, spent 10s of billions of seconds, and growing!

We're also working on the Premed Super App, same thing for people taking medical school entry exams like the MCAT or MDCAT.

I get to work with a bunch of top notch students and doctors, and I myself am the first ever full-stack technologist who also is a doctor in Pakistan, a country of 250 million people.

I’m working on a desktop app called With Audio https://desktop.with.audio a one time payment desktop app.

— it turns ebooks, articles, and documents into synchronized audio with real-time text highlighting. It’s great for people who prefer listening while reading (or want to stay focused), and it works fully offline with a one-time purchase — no subscriptions.

I’m bootstrapping it and trying to figure out how to market it effectively. So far, I’ve had some traction and early sales just by posting on Reddit, but I’m still learning the marketing side — especially how to reach people who’d benefit from it most.

Would love to hear how others approached early growth for similar bootstrapped tools.

I'm working on a simple, local storage budgeting app called "Wasa Budget". I wrote it because I got tired of tracking my budget on excel sheets. It's written in flutter, it works well enough that I was able to entirely ditch the excel sheets now.

I want to publish it on Google play, but I need testers. If anyone cares about budgeting, I'd love to get some feedback.

Here's the app link: https://play.google.com/apps/testing/dev.selfreliant.wasa_bu...

I don't think you can download it without being added to my testers list though. Send me your Gmail address if you're interested!

I am trying to quit IT and become full-time games/books/gamebooks publisher. I tried crowdfunding once and it turned out very well so I am working on next projects now :) https://gamefound.com/en/creators/arispen

https://klutz.co.in is my main project. It started with the desire to create powerful AI free-of-cost, for me (the dev) and for you (the user)! This is how it works: 1. You login or signup using puter. 2. That's it!—you can now Chat with any website, a lot of LLMs and 19 other AI tools for entirely free.

But here's my problem: Not able to monetize Klutz. Because puter Auth doesn't let you track the email ID of users. So, they can just delete their puter account from puter.com and create a new one with the same email, to use the free trial again. This will make the pricing pointlessand abuse the system!

Any ideas other than ads? Anything would help!

Just published my Chrome extension that makes finding new content on YouTube easier!

https://chromewebstore.google.com/detail/relevant/fdhnccpldk...

Two months ago I posted an update that I had begun work on my Chrome extension [1] for Relevant. Relevant is a crowdsourcing website where users can categorize the channels they watch into a defined hierarchy of categories ranging from broad topics like "Science" and "Gaming" to more specific ones like "Phone Reviews" or "Speedrunning".

Although I had a little bit of engagement on the website, I found myself looking for something that could bring the experience onto YouTube, so I began work on a Chrome extension. It turns out there's a lot more complexity in building a Chrome extension than I realised. It's basically like building a website for the popup window, a javascript server for the background service workers and a message bus for the service worker.

After 2 months' of working weekends, I finally released a version of it that lets users see the categories of the content on the page, discover more channels matching those categories and contribute to the categorisation effort!

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

Nothing actually. Feels nice.

I've been building an interactive nuclear reactor scoping tool to help people build intuition about how different types of nuclear reactors work and cost at different sizes. I ran a bunch of simple reactor simulations and this basically interpolates between them. https://whatisnuclear.com/neutronics-scoping-tool.html

I did a screenshare demo of it yesterday: https://www.youtube.com/watch?v=GQzDfrdf71Y

I wrote a simple app last year that put all my Apple Watch workout routes on a simple map, so I can see how much of the city I’ve covered (all existing options were paid, and I was too cheap for it). Now I have some time, so rewriting it properly that’s based on neighbourhood, completion %s, achievements and etc. It’s weirdly fun, because I’m not a mobile engineer, but satisfying to see hundreds of users per month using my app.

Also, every region has different ways of representing a “neighbourhood”, so I get to learn how to extract viable data from each city. Lots of map stuff, I’m genuinely enjoying it!

https://github.com/nixiesearch/nixiesearch

A Lucene-based search engine on top of S3 block storage.

Index schema is immutable (but supports migrations), so you cannot just screw up your index.

Separate indexer/searcher tiers, so heavy indexing load does not affect search latency.

And embedding/reranker local inference, so you can run the whole AI search within a single docker container.

Project Frottage: An automated constant stream of high quality AI wallpapers for mobile and desktop. We manually curate a list of ~150 prompts. Every 6h a random prompt is selected, a picture generated and uploaded to static hosting, free to use:

https://frottage.app/static/wallpaper-mobile-latest.jpg

https://frottage.app/static/wallpaper-desktop-latest.jpg

https://frottage.app/static/wallpaper-desktop-light-latest.j...

We just finished an android app, to set the wallpaper automatically on mobile: https://play.google.com/store/apps/details?id=com.frottage

Working on Cursor for Excel: https://www.tryalphaexcel.com/

As there is no open source version of Excel except Libreoffice, working to build the core Excel functionality with other open source packages. Then bringing in agentic editing functionality for real world data.

What is also has been interesting is to introduce banker/consultant formatting guidelines to the agent and making it beautify its work whether in tables or models.

I’m working on https://finbodhi.com — a double-entry personal finance tool where you own your data. It’s local-first, syncs across devices, and everything’s encrypted in transit.

It helps you track, understand, and plan your personal finances — with a proper accounting foundation.

It's interesting in many way. Using double-entry (it's a perspective shift), the technical challenges of building local-first app, UI/UX & visualizations, privacy and more.

I was trying out an MCP tool and hit few issues, even though there is MCP inspector which sets up a webserver etc. I wanted much simpler tool I can use in SSH environment, so I built (with Claude Code) a terminal tool to proxy any stdio MCP server and then use the monitor TUI to see all the flow of calls between MCP client and server. Its been helpful to learn thing about MCP as you see the flow of calls happening and inspect them.

https://github.com/zabirauf/mcp-trace

I'm making a kind of "Tinder for hiking trails".

I live in Switzerland and am (like many people here) an avid hiker. There are a lot of great hiking websites but they all suffer from the same problem: They are ultimately just a list of hiking routes that you need to plan around. Because I do a hike almost every week, the extra planning has become an overhead that takes time out of my life: how far away is it, what train should I take, whats the weather situation like, do I need to bring snowshoes, etc. The 65,000km of trails in this country also gives me decision paralysis!

So I'm building an app (React native/django) which takes a users current situation and preferences and then algorithmically suggests a few best options for them that they can quickly give a yes/no to. It's integrated with a lot of data like the train timetables, snow data, weather forecast etc.

I was able to reduce an hour of planning down to 5 minutes last week, so it's definitely working for me. What I am currently trying to do is figure out if other people have this problem and there's interest in the app concept.

I moved my blog over to Jekyll hosted via Github: https://blog.andrewrondeau.com/

The site itself isn't anything "special." I've had a personal website for about 25 years; the past few years I finally moved from making HTML by hand to using various CMSes. I tried a "no database" CMS that my hosting page had, then I wrote my own CMS, https://github.com/GWBasic/z3, to learn node.js, but then I had to go back because Heroku dropped the free tier.

Jekyll is interesting. As a Mac user, I'm surprised there isn't a push-button app, like MAMP, to just run it. Instead, I got exposed to some weirdness with Ruby versioning that, because I don't have any Ruby experience, was frustrating.

The default Jekyll template has warnings, but when I tried to fix them, I ended up jumping into a rabbit hole of sass versioning.

I also ended up jumping into a rabbit hole with setting up redirects from old urls on my blog to their new locations. I don't touch Apache / cpanel that often, so there was a bit of a learning curve for me.

One funny thing was that I set up two redirects, in cpanel, from the same url to two different urls. (It was a mistake!) I couldn't delete them, so I had to submit a service request with my host.

Two interesting things that I do not have time to do:

- Set up Github actions to deploy on my original host (andrewrondeau.com) - Set up redirects from blog.andrewrondeau.com -> andrewrondeau.com

Sometimes you wish you had best of hn summarised somewhere but that 'best' may be different to different people based on their interests. I'm therefore collecting links I find important, from hn and beyond.

https://linkshof.com

Thinking about:

How will various Human Computer Interaction change as many of current apps (which are screen based UI with some background code) simply get replaced with chat/voice/gesture based requests to LLM

Lately I've been trying to detect/mitigate prompt injection attacks. Wrote a blog post about why it's hard: https://alexcbecker.net/blog/prompt-injection.html

https://www.dreamsign.ai/

An AI-native DocuSign

It's been around a month I've been working on it. Struggling with getting people to actually use it - this week I've set the ambitious goal of 10 new contracts sent *and completed* by people I don't know (last week's was 10...by people I do know).

It's hard because I feel I'm in a weird hole - in order to have a good product I need people to use it and give me feedback, but in order for people to use it and give me feedback I need a good product. It's like wth!

Another thing I'm struggling with - enjoying the process. I get daydreams like mad. I feel I'm always living in the future in some way, especially with this software, and it's taking away from being present in this work. Which sucks, because I want to be excited to *work* on this and NOT fake my own excitement towards this as a manifestation of my greed to get rich off it.

But MAN am I greedy. It's ugly sometimes, to myself.

But god how I love to work on software also. How I love making stupid bash commands on my terminal. How I love to feel like the old gods, who conquered the infant digital world.

1. A general-purpose Bitemporal Data Schema using SQLite (for storage) and Clojure (for data processing).

I'm trying to see if I can "get away with it": no schema migration, no fixed views, one tenant per DB, local-first-friendliness.

The general approach is "Datomic meets XTDB meets redplanetlabs/Rama meets Local First". Conceptually, the lynchpin "WORLD FACTs" table looks like this:

  | tx_id  | valid_id | tx_t    | valid_t | origin_t | entity | attribute | value | assert | namespace     | user | role |
  |--------+----------+---------+---------+----------+--------+-----------+-------+--------+---------------+------+------|
  | uuidv7 | uuidv7   | unix ms | unix ms | uuid7    | adi    | problems  | sql   |      1 | org.evalapply | adi  | boss |

A workshop I've been experimenting with, using willing friends as guinea pigs. To help people remove friction from being able to "spool brain to disk". The sales-y part is here, with more context / explanation about what it is about and what it is not about: https://www.evalapply.org/index.html#writing-for-nerds

A JS framework called Torpor: https://torpor.dev (https://github.com/andrewjk/torpor)

Been working on this for a while, with the aim of making something simple and immediately usable. Components are JS functions, containing UI that is (mostly) HTML, with reactivity only done through proxied objects.

To test it out I built a distributed social media/microblog site called Redraft: https://redraft.social (https://github.com/andrewjk/redraft)

Self-hostable or hosted for a fee, all your posts stored in an SQLite file, comment/like/react on other people's Redraft posts via a Web extension (pending approval, but you can use the unpacked version from source).

Both are in a pretty rough state, but usable for the intrepid.

I'm working on a system to help people write their Family History.

You upload interviews with family members (text, audio or video all work) and the system automatically transcribes the text, finds key people or events, and puts it together with other information you may have gathered about those events or people before. Like building a genealogical tree but with the actual details about people's lives.

In the works to also attach pictures of said people and events to give it some life.

I am working on Community Notes for Bluesky: https://github.com/johnwarden/open-community-notes

The stuff I'm working on never feels worth sharing, but I am doing a lot of computer stuff lately. It's kind of the year of moving towards declarative setups for me.

- Migrating to Niri on my laptop and re-evaluating my literate config approach, switching from xkb configs to kanata and a few other QOL changes to make my tooling more composable and expressive

- Shoring up my blog / media sharing infrastructure (migrated to a landing page on an s3 bucket, with different prefixes for several different hugo deployments for different purposes, still need to get better about actually posting content)

- Preparing to migrate a bunch of my self-hosted services to a k8s cluster which can can be fully deployed locally for testing and defined in code. All this is managed through argo and testable with localstack and crossplane for some non-local resources

- Attempting (somewhat unsuccessfully) to setup a nixos config for a bunch of services that just don't feel right to run in containerized stack that I want to live in ec2 and have as close to 100% uptime as possible (uptime kuma, soju/weechat relay/bitlbee, conduit, radicale, agate, whatever else I think of that is small and has a built-in nixOS service module. Thinking about some kind of RSS aggregating solution here as well)

- Experimenting with vibecoding by trying to get an LLM to do the legwork to build a TUI interface to ynab using rust (which I don't know how to write)

I'm hoping that by the end of this summer most of the tooling I use for most things will be way more concrete and seamless. I also want to get my workflows down and get on top of converting at least a few the ~100 draft blog posts I have laying around into something I can actually post. Ditto for my photography albums, which are not yet organized into coherent groupings or exported for web.

Having worked on various products and startups before, I want to make it easier for solo-founders and small teams to understand website traffic, conversions, product usage, errors their users are having and provide support to their users, without having to intergrate and maintain multiple disjointed tools.

That's why I am building Overcentric - a simple and affordable toolkit that combines web & product analytics, session replays, error reporting, chat support and help center - all in one place.

Been building it and testing with several startups and improving based on their feedback. I am also using Overcentric for Overcentric itself, so I always get ideas for improvement.

What's next: more tools that are useful for startups are on the roadmap and I am exploring how LLMs can be further utilised (apart from support, session replay summaries, aiding in writing help center articles) and refining pricing.

Check it out at https://overcentric.com/

Would love to connect with other SaaS founders and have Overcentric help them grow their startups.

Syntax highlighting caught my interest after I created a data format. I stumbled upon TextMate grammar bundles which are supported in some editors and created a bundle that works with three of them. The gnome text editor uses a different language definition format for which I created a grammar file as well. [1]

To highlight the syntax in the browser I checked out the CodeMirror project that uses Lezer grammars. It is very flexible and allowed me to implement additional features like custom folding. [2]

I would also like to create a grammar for tree-sitter, finish the Java implementation and documentation of the ESON parser before I try to implement it in other languages.

[1] https://gitlab.com/marc-bruenisholz/eson-textmate-bundle [2] https://gitlab.com/marc-bruenisholz/eson-lezer-grammar

Newly Registered Domain block lists for PiHole[0]. This has worked hands-off for the last two days after a couple of weeks of tweaking. My PiHole blocklist is currently a bit over 14 million domains, of which around 8 million are NRDs.

My next item is to add AbuseIPDB IP addresses to my "Uninvited Activity"[1] IP address blocking system, implementing xRuffKez's script here: https://github.com/xRuffKez/AbuseIPDB-to-Blackhole

Unfortunately, but also understandably, AbuseIPDB limit their free-access (account required) API to 10,000 IP address records. So I might be putting it into a database to hopefully aggregate multiples of the 10k results if they're not always the same 10k.

[0]: https://github.com/UninvitedActivity/PiHoleLists

[1]: https://github.com/UninvitedActivity/UninvitedActivity

Not a technical project in the typical sense, but I finally started working on a satirical faux-exposé series about my years working in the industry.

If anyone's interested in that kind of thing:

https://massiveimpassivity.substack.com/p/softcore-how-nobod...

I'm building a budget app for my wife and myself.

Basic goals:

- Web based for zero update latency

- Have it work offline

- Automatically import transactions from my banks

- No running/hosting cost

- Secure

Tools used so far:

- InstantDB for the datastore, providing the offline capability too

- A gmail account that automatically gets forwarded bank alerts for purchases

- Gitlab.com w/scehduled pipelines for cron based email-syncing

- Netlify for the free hosting

- InstantDB magic codes / email links for securing the data

I'm at the point where I can track and categorize purchases, including split transactions.

Next steps:

- Add in date ranges for reporting / data views; e.g. show expenses incurred in a one month period instead of for all time.

- Add in planned / project transactions for month forecasting

- Statement import & import reconciliation and statement reconciliation

- Scrape company specific digital reciept emails (like Amazon) to autopopulate more transaction data

And that'll be the end of the stuff I can do for free. I think I will add features that require money and/or dedicated hardware though:

- OCRing receipts -> autopopulated transaction data / description

- Using chatgpt to suggest categorizations

- Scrape extra data from my bank sites, like physical addresses of entities involved in charges.

Been building my YouTube channel where I cover things like Apple Vision Pro development — as well as some new storytelling directions for me, like my newest short on the Voyager mission's camera problems when it was 2 billion miles from earth:

http://youtube.com/@dreamwieber

In parallel I'm working on a bunch of apps for Vision Pro -- my most well-known at the moment being Vibescape which was featured recently by Apple: https://youtu.be/QcTiDBtCafg

To round this out, my wife and I are converting a historic farm in the Pacific Northwest to regenerative agriculture practices. So far we've restored over 20 acres of native ecosystems.

If that's interesting to you there's a channel here:

http://youtube.com/@cleryfarm

https://github.com/patched-network/vue-skuilder https://patched.network

FOSS toolkit for SRS and adaptive tutoring systems. Inching closer to proper demos and inviting usage.

In essence, I'm looking to decouple ed-tech content authoring (eg, a flash card, an exercise, a text) from content navigation (eg, personalizing paths and priorities given individual goals and demonstrated competencies), allowing for something like a multi-sided marketplace or general A/B engine over content that can greatly diminish the need to "build your own deck" for SRS to be effective.

Project became my main focus recently after ~8 years of tiny dabbling, and I've largely succeeded at pulling spaghetti monolith into a sensible assembly of packages and abstractions. EG, the web UI can now pull from either a 'live' couchdb datalayer or from statically served JSON (with converters between), and I'm 75% through an MVP tui interface to the same system as well.

My team and I are building a web app that enables any business to chat with any other business in any language. Details:

It's B2B only - can't register with a free email provider, gotta own a real domain -Therefore identities are collective - companies, not company employees --Therefore all interactions are persisted at the org level rather than assigned to individual inboxes

-It allows you not just to talk but also to work together on contracts. We built a contract parser that turns contract clauses into smart, plain language objects

We're calling it Geneva and doing a friends/family/acquaintances exploratory release as I type this.

http://genevabm.com http://x.com/genevab2b https://www.linkedin.com/company/genevabm/

My Carnatic Raga classifier is progressing very well. I am now training a classifier to identify 142 ragas.

A bit of background: I have been working on a Raga classifier since November of last year - I started with just 2 ragas and a couple megabytes of audio. After experimenting with a lot of different ideas and Neural Net Architectures, I finally landed on one that could scale. I increases to 4 ragas, then 12, then 25 and then to 65.

All the training is done locally on my desktop (RTX4080, AMD 7950X, 64G RAM). My goal is to make an app for fast inferencing (preferably CPU) and to get this app in the hands of enthusiasts so that I can get some real data on its efficacy. If that goal is hit, then my plan is to iterate and keep increasing the raga count on the model and eventually release to the public. As long as I can get the model to either run locally or for very cheap on server, I hope to not charge for this.

It has been an amazing learning experience. The first time I got a carnatic singer to sing and the model nailed almost all ragas was the highest high I've felt in a while.

I posted a couple of months ago:

https://github.com/dahlend/kete

Research grade orbit calculations for asteroids and comets (rust/python).

I began working on this when I worked at caltech on the Near Earth Object Surveyor telescope project. It was originally designed to predict the location of asteroids in images. I have moved to germany for a PhD. I am actively extending this code for my phd research (comet dust dynamics).

Its made to compute the entire asteroid catalog at once on a laptop. There is always a tradeoff between accuracy and speed, this is tuned to be <10km over a decade for basically the entire catalog, but giving up that small amount of accuracy gained a lot of speed.

Example, here is the close approach of Apophis in 2029:

https://dahlend.github.io/kete/auto_examples/plot_close_appr...

A Parquet file compactor. I have a client whose data lakes are partitioned by date, and obviously they end up with thousands of files all containing single/dozens/thousands of rows.

I’d estimate 30-40% of their S3 bill could be eliminated just by properly compacting and sorting the data. I took it as an opportunity to learn DuckDB, and decided to build a tool that does this. I’ll release it tomorrow or Tuesday as FOSS.

We're building Zigpoll (https://www.zigpoll.com), a survey platform focused on zero-party data collection — think post-purchase attribution, customer feedback, and segmentation — all done directly on your site without relying on third-party cookies or offsite links.

We initially built it for Shopify, but now it’s fully embeddable, supports headless implementations, and integrates with tools like Klaviyo, Zapier, n8n, and Snowflake. One thing we’re especially proud of is how fast and unobtrusive it is: polls load async, don’t block rendering, and are optimized for mobile and low-latency responses.

From a tech angle:

Frontend is all React, optionally SSR-safe.

Backend is Node.js + Postgres, with a heavy focus on queueing + caching for real-time response pipelines.

API-first design (public API just launched: apidocs.zigpoll.com).

We recently open-sourced our n8n integration too.

If you're a dev working on ecom, SaaS, or even internal tooling and need a non-annoying way to collect structured feedback, happy to chat or get you set up. Feedback welcome — especially critical stuff. Always looking to improve.

https://sivic.life

The premise is that when I read social spaces like Reddit or X, if the government has done anything contentious you get nothing more than strident left takes, or strident right takes on the topic. Neither of which is informative or helpful.

So I have set up a site which uses AI which is specifically guided to be neutral and non-partisan, to analyses the government actions from the source documents. It then gives a summary, expected effect, benefits and disadvantages, and ranks the action against 19 "things people care about" (e.g. defence, environment, civil liberties, religious protection, etc.)

The end result is quite compelling. For example here's the page that summarises all the actions which are extremely beneficial or disadvantageous to individual liberties: https://sivic.life/tyca/tyca_individual_liberties/

Insurance is negative NPV. Trying to make it NPV neutral by giving people tools to self-insure. Starting with an app that lets you self-insure your phone with friends and family.

https://apps.apple.com/us/app/open-insure-self-insurance/id6...

I'm working on a little website to summarize discussion trends across the podcast ecosystem. I wrote about an early prototype here[1] and also gave a presentation about it a few months ago[2] and now I'm working on an expanded "daily pulse" view across hundreds of episodes of top news podcasts from the last few days.

My secret agenda is to explore how the "information supply chain" can be tracked across the data-processing stack all the way from the original audio through transcription, the processing pipeline, and UI. I'm using language models for multi-stage summarization and want to be able to follow the provenance of summaries all the way back to the transcripts and original audio.

[1] https://yuri.is/n/podcast-vibes-prototyping/

[2] https://yuri.is/n/podcast-vibes-presentation/

Been working on a small team exploring what the intersection of coaching, employee engagement, and AI looks like. (https://engage.myemmaai.com/)

Most employee engagement software is just placation for HR. When it's common that the lowest scoring question on feedback cycles is "I believe that action will be taken based on the results of this feedback," there's something fundamentally broken with how companies handle feedback, and how the tools their given enable them to react to it.

Our end goal is to help leaders and managers identify problems with trust and communication within a team. The reality is, 90% of the time, the problem lies with the leadership itself. We're trying to provide both the tools to diagnose what the problems are, and frameworks for managers to fix them.

Along with what feels like billions of others right now, I'm building a pet project as a learning exercise involving rag agents, MCP and locally hosted llm's to work with a 15 year old pile of proprietary wiki data and a large 20yr old codebase.

I am building a Hardware Design Language for FPGA accelerators.

The big trick or the language is that it doesn't hide the pipelining you have to do to up your FMax, instead, you can manually add register stages in the places they're important, and the compiler will synchronize the other paths.

A really neat trick with this pipelining system is that submodules can respond to the amount of pipelining around them (through inferring template parameters). This way the programmer really doesn't have to think about the pipelining they do add. Examples are a FIFO's almost_full treshold, inferring how many simultaneous state there needs to be for a pipelined loop, inferring the depth of BRAM shift regs, etc.

https://sus-lang.org

https://github.com/pc2/sus-compiler

I built an IPC/RPC shim for a Chrome extension so I can send strongly-typed messages between isolated JS contexts that otherwise expose wildly inconsistent messaging APIs.

I discovered that VSCode has a very nice solution so I pulled the core VSCode libraries and injected them into a Chrome extension using the dependency injection, ipc / rpc, eventing to bridge the gap between all of these isolated JS contexts and expose a single, strongly‐typed messaging API, my IPC/RPC shim sits on top of each of the native environments and communication mechanisms.

Yesterday, Microsoft released the source code for the Copilot chat. Apparently, since the basis of my Chrome extension is the same core libraries I can drop the VSCode chat UI into the side panel without much friction. Although, I might continue to use Microsoft's FluentUI chat currently implemented in the extension.

Because Copilot chat has a lot of code that runs in node in Electron, now I'm working in porting all the agent capabilities for browser automation from the Copilot chat including the code for intent, prompt creation, tools, disambiguation, chunking, embedding, ect. I'm 4 to 6 weeks away from having feature parity of Playwright for automation from a Chrome extension side panel that can do most of the inference using huggingface transformer.js locally. Nonetheless, heuristics exposed as tools such that if the intent is playing a video, all that is required is a tool that collects all the video tags and related elements with metadata. No need to use $10 in tokens to figure out which video element to play.

Yeah, I think I'm 4 to 6 weeks away from having a Copilot chat in a browser doing agent automation.

If you want to see where I'm at today, https://github.com/adam-s/doomberg-terminal.

I have a nice garden going right now. TAM Jalapeños have taken the longest to flower, almost thought they wouldn’t. Sweet cherry peppers have been plentiful. Lost my zucchini crop to squash vine borers.

Currently, in a side project to keep track of pricing in the supermarkets, as since the start of the war of Ukraine, the prices have raised, event skyrocketed in some cases, without any real explanation. In some cases, I've seen how a product has raised up to 1€ in some months. The way to keep the pricing changes is to take a picture of a supermarket receipt, store the information, and calculate the pricing diff for each article. For extracting the information, I use Textract from AWS, as it fits my needs, however, it could be possible to replace it with any other OCR which can extract structured information. My purpose is to improve the project gradually and add statistical information, like charts showing the pricing changes along the time, show the most bought products in a period of time, etc

As the project relies on AWS service, I have decided to not publish a free demo, as it would be exposed to abuse by sending all kind of images, not to talk about crazy billing. However, here is a screenshot on how does it display the receipt details:

https://ibb.co/pv2ksRhH

There is a raise on one article, and a down on some others

The project is built using Ruby on Rails and runs on docker. It is light enough to run on a cheap VPS.

Feel free to take a look on it: https://gitlab.com/cbolanos79/sbt_rails

Any constructive opinion/collaboration is welcome :)

I'm working on a free high performance address matching (geocoding) library. As it turns out I blogged about it just today: https://www.robinlinacre.com/address_matching/

Repo: https://github.com/ilmoraunio/conjtest

Conjtest is a policy-as-code CLI tool which allows you to run tests against common configuration file formats using Clojure. You can write policies using Clojure functions or declarative schemas against many common configuration file formats such as YAML, JSON, HCL, and many others (full list in repo).

Under the hood, it uses Babashka and SCI (Small Clojure Interpreter) to run the policies and Conftest/Go parsers for compatibility with Conftest (https://www.conftest.dev/). It’s also possible to bring your own parser or reporting engine using Babashka scripting.

The initial big pieces are in place now, I’m preparing my end of the year to talk about Conjtest and get some feedback/issues to work on.

Hey HN – I'm working on OneBliq https://onebliq.com, a lightweight tool to help teams plan and track Azure costs collaboratively, without the usual enterprise overhead.

We built it because managing cloud budgets often turns into a spreadsheet mess, or worse, a never-ending consulting engagement. OneBliq lets you:

* Split and allocate Azure costs by cost centers, teams, or projects

* Visualize current spend and attention areas at a glance

* Experiment with plans and projections without complex tooling

* Skip sales calls and long onboarding – just install and kick the tires

It's still early, but we're seeing traction with teams who want clarity without complexity. Happy to answer questions, share more, or get feedback.

Would love your thoughts – what would make a tool like this useful (or useless) for you?

I just started on an old-school forum software. Go + Sqlite. Good old server-side HTML templating.

Why? I don’t like Discourse and Flarum that much. I want an even simpler solution with fewer bells and whistles.

But I guess the market is dead anyways for forums. I might replace my phpBB instance that has been running for 15 years.

I've been working on my own version of a literate programming system (https://github.com/adam-ard/organic-markdown). It's kind of a mix of emacs org-mode, jupyter, and Zettelkasten. But, because it's based on standard pandoc-style markdown, you can use it with a much wider range of tools. Any markdown editor will do.

Even though I made it as a toy/proof of concept, it's turned out to be pretty useful for small to medium size projects. As I've used it, I've found all kinds of interesting benefits and helpful usage patterns. I've tried to document some; I hope to do more soon.

--https://rethinkingsoftware.substack.com/p/the-joy-of-literat...

--https://rethinkingsoftware.substack.com/p/organic-markdown-i...

--https://rethinkingsoftware.substack.com/p/dry-on-steroids-wi...

--https://rethinkingsoftware.substack.com/p/literate-testing

--https://www.youtube.com/@adam-ard/videos

The project is at a very early stage, but is finally stable enough that I thought it'd be fun to throw out here and see what people think. It's definitely my own unique spin on literate programming and it's been a lot of fun. See what you think!

For fun, I am building a little tool called 'domain-manager'. Basically just a binary that automates configuring a Linux host to run a bunch of WordPress/Laravel/PHP sites.

It creates all the necessary boilerplate to generate PHP Docker containers, creates all of the MySQL users, and sets up all of the directory structures to get a new website up and running. It even helps set up SFTP users and gets letsencrypt certificates set up with certbot.

It's still very early days, but I appreciate that what used to be a bunch of commands that I would run by hand and slightly change every few months is now pretty much just all self contained. Should mean the next migration to a different server is easier.

Created in frustration because I was too cheap to pay the $50/month for a cPanel license.

https://github.com/timgws/domain-manager

Still building: https://www.saner.ai/

The ADHD-friendly AI personal assistant for notes, email, and calendar.

Where you can just chat to search notes, manage emails, and schedule tasks. It proactively plans your day every moring and checks in to help you stay on top of everything.

Continuing to plug away at Trilogy, a better SQL for data consumption and analytics. Getting closer to core feature completeness, at which point can pivot to focus on integrated visualizations + pre-processing/ETL.

Most recently have been focused on better geographic visualizations in the public studio for people to experiment - getting decent automatic lat/long, want to have easy path visualizations (start/end, etc). More AI-accelerated options as well, especially around model authoring.

Repo: https://github.com/trilogy-data/pytrilogy Studio: https://trilogydata.dev/studio-core/

I built a hardware server monitor with LED display based on the ESP8266. I needed 8 fewer things to think about in the morning. If you want, you can build one yourself, I released the hardware and firmware: https://github.com/seanboyce/servermon

Next up is a small lamp for migraines. I noticed that dim red light is much more tolerable to me than anything else. I mean obviously, darkness is ideal, but you need to do other stuff like eat and drink eventually if it's a persistent one.

So I designed a quick circuit to use fast PWM (few Mhz, so no flicker) to control a big red LED. I'd like it to be sturdy and still functional in 50-100 years, so made some design choices for long-term durability. No capacitors, replaceable LED and so on.

A simple project, but it's a busy month and I need something easy this time.

I'm putting the finishing touches on my free daily word game, Omiword[1][2]. I had it basically finished, with the option for players to make a one-time $5 payment to unlock access to the archives, but then Stripe shut down my account, claiming it was a "restricted business".[3] I'm now reworking it to try to fund it through Patreon, we'll see how that goes.

[1] https://www.omiword.com

[2] https://news.ycombinator.com/item?id=43654350

[3] https://news.ycombinator.com/item?id=44075038

A better paint-by-numbers generator than what I found online.

Examples wiki: https://github.com/scottvr/pbngen/wiki

The code: https://github.com/scottvr/pbngen

A tool for creating WCAG/ADA accessible Tailwind-like color palettes. :)

https://www.inclusivecolors.com/

The idea is it helps you create palettes that have predictable color contrast built-in, so when you're picking color pairs for your UI/web design later, it's easy to know which pairs have accessible color contrast.

For example, you can design your palette so that green-600, red-600, blue-600, all contrast against grey-50, and the same for any other 600 grade vs 50 grade color, like green-600 vs green-50.

That way you won't run into failing color contrast surprises later when you need e.g. an orange warning alert box (with different variations of orange for the background, border, heading text and body text), a red danger alert box, a green success alert box etc. against different color backgrounds.

Updating a treatment of a finite difference approach to Schrodinger's equation from WebGL to WebGPU, using WebGPU compute shaders. Having actual arrays for data storage is so much cleaner than the older approach with textures for data storage and fragment shaders for computations. https://www.vizitsolutions.com/portfolio/webgpu/compute/ Once this is caught up with the earlier version, I'll be extending it in terms of additional numerical issues and techniques and use it to build explorable educational content in 1-D quantum mechanics. Eventually, on to 2-D quantum mechanics.

I welcome feedback, just keep in mind that this is a work in progress, and I haven't even reviewed it for clarity and typos.

Currently building a SaaS for product management to make up for some of my own defects. Looking for beta testers if anyone is interested in trying it and providing feedback. There will definitely be bugs but I plan to start using it for myself to help me keep up on some projects I'm working on. The big thing I'm excited about is AI Risk Analysis, which will review the dependencies and hopefully catch bottlenecks and issues before they cause misses. Current URL is below. Name is pending. Just had Google tell me something that sounded cool.

https://axonmesh.pages.dev/

Open source quiz creator to create quizzes by pasting in text or selecting from a large range of historical categories.

Started as a very simple app for me to play around with OpenAI’s API last year then morphed into a portfolio project during my job search earlier this year. Now happily employed but still hacking on it.

Right now, a user can create a quiz, take a quiz, save it and share the quiz with other people using a URL.

Demo: You can try out the full working application at https://quizknit.com

Github Links: Frontend: https://github.com/jibolash/quizknit-react , Backend: https://github.com/jibolash/quizknit-api

I've been hacking on an Icecast-compatible server with Erlang. You can feed it an FFmpeg icecast feed into the server, and listen to it with any Icecast-compatible player. I think it's kind of neat; I do some extra things that the official Icecast server doesn't give you.

I store the chunks in a custom-built database (on top of riak_core and Bitcask), and I have it automatically also make an HLS stream as well. This involved remuxing the AAC chunks into MPEG-TS and dynamically create the playlist.

It's also horizontally scalable, almost completely linearly. Everything is done with Erlang's internal messaging and riak_core, and I've done a few (I think) clever things to make sure everything stays fast no matter how many nodes you have and no matter how many concurrent streams are running.

I'm working on a new kind of encyclopedia and reference website that is way more engaging and rich than a single page of text on every subject like Wikipedia. Back in my childhoold we had Microsoft Encarta on CDROM and it was a very compelling multimedia experience and I want to emulate something like that on the modern web by combining video, sound, images and text in a more compelling user experience with great discoverability. I've been working on the first version for about eight months and I hope to launch it next week at https://reference.org

I've been quite obsessed about ramping up (technically complex, not basic crud/wrappers) SaaS development with Gen AI tools, speeding things from months to weeks to days. But then I hit a snag: operations are the new bottleneck. How can I support all of these products, let alone promote them or find customers? My focus shifted to agents, and I realized that access for these AI bots was a major hurdle, despite all the MCPs available.

The thing is, we’ve been retrofitting software made for humans for machines, which creates unnecessary complications. It’s not about model capability, which is already there for most processes I have tested, it’s because systems designed for people are confusing to AI, do not fit their mental model, and making the proposition of relying on agents operating them a pipe dream from a reliability or success-rate perspective.

This led me to a realization: as agentic AI improves, companies need to be fully AI-native or lose to their more innovative competitors. Their edge will be granting AI agents access to their systems, or rather, leveraging systems that make life easy for their agents. So, focusing on greenfield SaaS projects/companies, I've been spending the last few weeks crafting building blocks for small to medium-sized businesses who want to be AI-native from the get-go. What began as an API-friendly ERP evolved into something much bigger, for example, cursor-like capabilities over multiple types of data (think semantic search on your codebase, but for any business data), or custom deep-search into the documentation of a product to answer a user question.

Now, an early version is powering my products, slashing implementation time by over 90%. I can launch a new product in hours supported by several internal agents, and my next focus is to possibly ship the first user-facing batch of agents this month to support these SaaS operations. A bit early to share something more concrete, but I hope by the next HN thread I will!

Happy to jam about these topics and the future of the agentic-driven economy, so feel free to hit me up!

My wife and I recently started sharing our passion for cooking at https://soulfulsabor.com. Got WordPress set up to get things running and focus on the cooking and photos. Wordpress turned out to be hyper complex for my taste and needs plugins for a lot of things, so I'm starting to develop my own static site for specifically for food blogs, not wanting to turn it into a product but just to add simplicity to our own workflow. The cooking side of the project is really fulfilling after a long day in the computer, it feels great to do something tangible with quick results. Got a bunch of bread recipes to upload soon.

I had been working on a macOS app last couple weeks. Got it approved by Apple today YAY!

It's called Heap. It's a macOS app for creating full-page local offline archives of webpages in various formats with a single click.

Creates image screenshot, pdf, markdown, html, and webarchive.

It can also be configured to archive videos, zip files etc using AppleScript. It can do things like run JavaScript on the website before archiving, signing in with user accounts before archiving, and running an Apple Shortcut post archiving.

I feel like people who are into data hoarding and self host would find this very helpful. If anyone wants to try it out:

https://apps.apple.com/ca/app/heap-website-full-page-image/i...

I've built a Reddit-like community platform in Go. Users can create their own sub-communities, and within them, set up different categories and boards. Posts can be voted on, and board types can include regular posts, Q&A, or live chat. It's like a hybrid of Reddit and Discord but leans more towards a traditional web community. It also supports server-side rendering, making it SEO-friendly. This project is an extension of my previous Hacker News clone, dizkaz (https://news.ycombinator.com/item?id=43885998). I'm currently working on implementing submission rate limiting and content moderation, which is a bit challenging, but it should be ready for launch soon.

Just like many others, I also have this problem: it’s getting harder and harder to find the articles I’ve read later. There’s so much great content I come across every day that, in my experience, it’s rather difficult, if not impossible, to find it again by searching Google. So I started building a personal solution to keep the stuff I read searchable.

There are existing tools that try to solve this, but I have some unique requirements that pushed me to create my own. Things like Telegram integration, weekly summaries, and indexing YouTube content. More importantly, I felt the pain enough that I was motivated to work on it as a side project.

A good example is the frustration and disappointment I had with Pocket: the search functionality was terrible, and each update seemed to make the product less usable.

I’ve now got a working prototype, and I’m putting on the final touches. Let me know if you have any thoughts, or email me if you’d like to try it out.

I'm building https://zenquery.app — a tool for querying large CSV, JSON, Parquet and Excel files using plain English. No SQL or coding required.

As a data engineer, I regularly have to dig through massive files to debug issues or validate assumptions — things like missing column values, abnormally large timestamps, inconsistent types, or duplicate records. It’s tedious and time-consuming, and that’s what led me to build this.

ZenQuery makes it quick and easy to explore data locally, without needing to spin up notebooks, write scripts, or upload anything to the cloud. It’s also useful for doing lightweight analytical QA if you're working with business data.

Happy to answer any questions.

https://dibsonstuff.com

a Slack and Discord app to help take turns (i.e. queue) with your teammates, overwhelmingly used for sharing tech resources like staging servers. It's crazy something that started so tiny (almost as a joke for my old workplace) has grown into my main "thing".

https://tfstate.com

an infrastructure configuration monitoring solution for terraform/opentofu managed stacks. I am unsure how to proceed with this tbh. It's sort of the underdog in this space - it's much cheaper than the competitors. But really, it's yet to make a dent.

(I am maybe prowling around for something new to build)

I have been writing a few technical posts about how ML is used to show ads: https://satyagupte.github.io/posts/how-ads-work/

I was hoping to make a piano practice assistant for my kids, that would take sheet music in MusicXML format, listen to the microphone stream, and check for things they frequently miss like rests, dynamics, consistent tempos.

Surprisingly the blocker has been identifying notes from the microphone input. I assumed that'd have been a long-solved problem; just do an FFT and find the peaks of the spectrogram? But apparently that doesn't work well when there's harmonics and reverb and such, and you have to use AI models (google and spotify have some) to do it. And so far it still seems to fail if there are more than three notes played simultaneously.

Now I'm baffled how song identification can work, if even identifying notes is so unreliable! Maybe I'm doing something wrong.

Just writing posts for my blog on personal experiences with startups https://developerwithacat.com . Am taking a break from any serious building, bit tired of failing. Using the blog as a form of self therapy.

Building TenantFit: https://tenantfit.mtxvp.com/, a lightweight tool to help small landlords pre-screen rental applicants.

When you post a listing (e.g., on Facebook, Kijiji), you get tons of “Is this still available?” messages — but no useful info. TenantFit lets landlords collect basic answers (income range, pets, lifestyle) via a public link, then ranks responses to highlight promising leads.

No accounts or sensitive info collected from tenants (landlord does not even see candidate email until they reply), just a quick pre-screen before deeper screening to save time.

I’ve been building my wife a budget tracking dashboard for reporting on PPC ad campaigns.

At any given time, she’s working with any number of clients (directly or subcontracted, solo or as part of a team) who each have multiple, simultaneous marketing campaigns across any number of channels (google/meta/yelp/etc), each of which is running with different parameters. She spends a good amount of time simply aggregating data in spreadsheets for herself and for her clients.

Surprisingly we haven’t been able to find an existing service that fits her needs, so here I am.

It’s been fun for me to branch out a bit with my technology selections, focusing more on learning new things I want to learn over what would otherwise be the most practical (within reason) or familiar.

Wut.Dev (https://wut.dev) - a fast, client-side, privacy-focused, alternative to the AWS console.

I got tired of using the AWS console for simple tasks, like looking up resource details, so I built a fast, privacy-focused, no-signup-required, read-only, multi-region, auto-paginating alternative using the client-side AWS JavaScript SDKs where every page has a consistent UI/UX and resources are displayed as a searchable, filterable table with one-click CSV exports. You can try a demo here[1]

[1] https://app.wut.dev/?service=acm&type=certificates&demo=true

My background is in NLP, research, and startups. I joined a power company where I saw a clear opportunity to use AI for automating equipment inspection from drone images.

But the environment made it hard to move fast. The systems were outdated, and there wasn’t much support for building AI tools in-house. That experience made me realize I needed to grow beyond the modeling layer. There were things I wanted to build, but I didn’t yet have the full skill set to do it on my own.

So I’ve been learning full stack development. I had built a small chatbot app before, but this time I’m applying what I’m learning toward a focused MVP for the inspection work. It’s been a practical way to connect what I know with what I want to make real.

Went down a bitcoin rabbit hole and got really interested in how wallets are derived with seed phrases. I wanted a simple and secure way to generate them from the terminal but could not find anything so I built my own: https://github.com/rittikbasu/s33d

A screen reader for linux. My aim is to carry around my Raspberry Pi 500 or some other mini keyboard with a tiny computer embedded in it and have it serve as a fully functioning computer.

My hope is to make it easier to use a computer blind than with my usual workflow with a monitor.

I'm working on Fro (https://fro.app)

Haven't released properly yet - not sure if it's stable but oh well.

I don't like using my personal email to sign up for things. But there are definitely things that I do want to sign up for - newsletters, try out some services.

I know there are temporary email services, but I actually want to use these services. Of course there is Apple email that forwards to your real email.

But, I also don't want to flood my inbox.

Anyway, I wanted to receive these transactional emails in my personal Slack.

So, that's what Fro is for (https://fro.app)

- Sign up - get an email address - link to your Slack channel

And you can now catch up on those newsletters via Slack.

I'm currently developing a middleware that connects Nvidia PhysX to GameMaker. There's still a lot of work left but I have most features working in some capacity. Dynamic and static actors, primitive/convex/triangulated shapes, joints, character controllers, GPU accelerated PBD particles and deformables, etc. GameMaker is primarily a 2D engine and offers limited options for 3D, but it is possible if you know how to use vertex buffers. I'll probably post it here once it's a little farther along, but I'm pretty proud of my progress so far. I'm hoping I can use it to support myself in some way, but there's a lot of anxiety in selling a niche project like this.

On a whim, I bought a pack of playing cards at the supermarket. Now I'm learning how to play card games.

The card maker has its own web site with the rules for playing all kinds of card games, and it's filterable by number of players, including many games for one person.

I wanted to learn a bit about backend development, so I've been building my own version of soundcloud with supabase. Main thing I've learnt so far, auth is flipping complicated. But it's been really fun! The audio compression is done clientside with ffmpeg and WASM, I'm pretty pleased with that approach. Everything is pretty busted atm, but I'm trying to get to a 'walking skeleton' then polish. I've been devlogging the process as I go for fun.

https://cassette.world/

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

This month I released USBSID-Pico v1.3 pcb via PCBWay and Retro8BitStore and yesterday firmware version v0.5.0-BETA. The new pcb now supports mixed MOS6581 / MOS8580 chips (voltage) at the same time and new firmware brings a lot of tweaks and improvements making Commodore64 digitunes play better on Windows.

USBSID-Pico is a RPi Pico (RP2040/W RP2350/W) based board for interfacing one or two MOS SID chips and/or hardware SID emulators over (WEB)USB with your computer, phone, ASID supporting player or USB midi controller.

More info at https://github.com/LouDnl/USBSID-Pico

I'm putting the finishing touches on VT[0] - a minimal AI chat client focused on privacy. No tracking, clean interface, with support for deep research, web search grounding, tool calls, and RAG... and more.

The code is all open source on GitHub[1]. Really close to shipping now - hope to share launch details soon.

These monthly HN threads have been great motivation for me to keep building consistently. Thanks everyone!

[0]: https://twitter.com/vtdotai

[1]: https://github.com/vinhnx/vtchat

I'm working on an online photo gallery platform for professional photographers. The MVP is ready, but I'm also using the opportunity to learn more about SEO, marketing, and communication. This is the URL: https://picstack.com

One interesting lesson is to see the effort involved in acquiring new customers and setting up funnels, especially when bootstrapping with a small budget. Sometimes, as developers, we are in our bubbles and don't realize how much skill one needs to figure out the customer acquisition domain.

https://pickyskincare.com - a tool that lets you find skin care products based on the ingredients you want and don't want in it. The main use case is for finding cheaper versions of a product you already like, or one without things you're allergic or sensitive to.

It's written in elixir using Phoenix live views. There's almost no custom Javascript outside of what that framework gives. First load may take a while because it's the cheapest tier of fly.io and boot loads all known ingredients and products in to memory.

https://figma-to-react-native.com

Plugin to convert Figma designs to React Native code fully client-side.

And a complimentary service that syncs the code directly to your filesystem in real-time, as well as an optional MCP server to flex the generated code to your codebase to fit your framework/libraries.

Source: https://github.com/kat-tax/figma-to-react-native

(includes cool tech like lightningcss-wasm for styles conversion and esbuild-wasm for client-side previews)

I’ve built the best way to learn over 120 languages to advanced levels (optimized for studying multiple languages in parallel): https://phrasing.app

I got the demo video produced, and a blog set up and seeded. You can see some of the science behind learning multiple languages at https://phrasing.app/blog/multiple-languages or follow my progress using Phrasing to learn 18+ languages at https://phrasing.app/blog/language-log-000

Now I’m working on the onboarding process, which I’m very excited about on both a product and a technical level. On the product level, it dovetails nicely into most of the shortcomings of the app. One solution to a dozen problems.

On the technical level, I’m starting to migrate away from reagent (ClojureScript react wrapper). The first step was adapting preact/signals-react to support r/atom, r/cursor, and r/reaction. This has worked beautifully so far and the whole module, with helpers, is less than 100 LoC. I’m irrationally excited about it, and every time I use any method it brings me a stupid amount of joy… especially since it’s exactly the same API as reagent.

For those curious, the next steps in the migration will be: upgrading to React 19 support once reagent ships with it (in alpha currently), then replacing the leaf components with hsx and working my way up the tree. No real code changes, just a lot of testing needed. Maybe at the end of it all, I can switch the whole app over to preact — will be interesting to test the performance differences.

As far as ideas I’m thinking about, I’m currently planning the next task in my head. This will be an (internal) clojure library that will hopefully have ClojErl (erlang), ClojureScript (js), and jank (C) interfaces, which means I’ll be able to write clojure once, and run on the server, browser, and mobile — all in their native environment. Needless to say, being able to write isomorphic clojure without running JavaScript everywhere has me almost as excited as my signals wrapper :D

I'm building the Enact Protocol: https://enactprotocol.com

Turn any command into an AI-discoverable MCP tool with a few lines of YAML:

   name: hello-world
   description: "Greets the world"  
   command: "echo 'Hello, World"

Still working on Alzo [1], my services startup for french architecture companies. These days I spend most of my time writing client-specific apps [2] that are hot loaded on demand into my Elixir monolith. So far I like this architecture a lot because it is hard to break anything in it.

[1] https://alzo.archi

[2] https://lucassifoni.info/blog/leveraging-hot-code-loading-fo...

I've been building a satirical t-shirt brand for the miserably employed: https://www.miserablyemployed.com/

https://readworks.app/ is an app to do research within PDF collections mainly for scientists or in the legal field. It’s an oss project I’ve worked on the last two years.

I’ve figured out that I lack in terms of marketing / sales and to develop successful strategies to gain visibility. So actually enjoining the summer rather than coding at night / weekends but still having plenty ideas how develop it further and assist analytical reading.

I'm building an Electron app that integrates with Shopify and QuickBooks Online to streamline operations for artist-led product businesses. As a jewelry maker, I'm automating the spreadsheets and photo archives I rely on to run my studio. I want a single source of truth for all the data scattered locally and across platforms: tracking material prices, calculating costs and labor, analyzing marketing ROI, and accurately updating cost of goods sold when a piece sells.

Working on a silly side project called SinkedIn — a parody of LinkedIn but just for posting failures, screwups, and embarrassing moments. Staging is live here: https://sinkedin-staging.vercel.app/ and GitHub repo is: https://github.com/Preet-Sojitra/sinkedin. Pushing to production soon. UI is rough, I’m not a frontend person — bear with me! All sorts of contributions are welcome.

https://askcrystal.info/dashboard

We aggregated half a dozen plus disparate data sources to create a comprehensive infrastructure map of the PNW power grid. Our goal is to be able to query for and provide informed answers for grid operators, investors, and other energy adjacent businesses in the space.

(For reference): The PNW has the most abundant clean power in the US and is one of the markets with most opportunity as our consumption increases with AI.

Working on my startup: ProtoMatter

https://www.protomatter.ai/

Automating Clean-room plant propagation using robots

There are about 2-3+ Billion plants cloned in laboratory conditions per year which are all done by hand. I am in the process of trying to develop a MVP to automate this task while also getting customer conversations to get early adopters.

What I am struggling with is that I don't know if I should focus on developing the MVP which will cost 20k-40k & 4-6 months to develop or put in place a pilot program to get customers willing to buy the machine / pay up front before I start developing. Hardware startups are rough usually because their MVP takes so long to develop.

I am currently bootstrapping while I am pushing for more conversations trying to do both at once. I could personally finance the venture, but it seems like a poor move to just take on all the risk personally? I have am setting up conversations with a few VCs, but that is a month out.

I'm working on this full time at the moment. I have a couple people who I have talked to who could be co-founders but nothing has materialized yet. So I am just all over the place at this stage in the process.

I spoke to 4-5 potential customers and 2-3 of which are 'interested' in what I have but seem only interested in the 'validation' stage which only comes up after the huge personal investment on my end.

I'm working on my first hide-and-seek game[1], built using my own 2D game engine[2]. The game's theme is dark and mysterious, with various subtle references.

Aside from that, I’ve also made some sillier little games/demos[3].

There’s a computer with a classic BASIC interpreter written in Lua after the first level.

1 - https://reprobate.site

2 - https://carimbo.site

3 - https://carimbo.games

I've been working on https://stacks.camera - it's an idea about overlaying the previous picture when you're taking a photo so you can create a timelapse or animation.

For example, you can scroll through 60 pictures from my window https://stacks.camera/u/ben/89n1HJNT

Most of the challenges are around handling images & rendering, but I've also been playing with Passkey-only authentication which I'm finding really interesting.

Integrating molecular dynamics into my protein viewer: https://github.com/David-OConnor/daedalus

I'm working on inq - a real ink pen that writes on real paper while simultaneously digitizing everything you write. Specifically working on the software for our mobile and web apps.

Among other things, my team has implemented access-based sharing using web links, like Google Docs for real paper handwriting. And we've just launched Quin, our AI assistant for real paper handwriting. Super useful for getting help with math, language learning, looking up relevant facts, generating ideas, etc.

See https://inq.shop/pages/app

Broadly: Still forging ahead building a game server framework in Erlang. I've shifted my attention away from Godot integration (which AFAIK is still working) and toward LÖVE and Lua. Godot is great, but having to write GDScript on the client and Erlang on the backend has caused me many headaches in my game logic. My current goal is to have a beautiful, concurrent, Erlang-based control plane with Lua-based game logic running on both the server and the client.

To that end, I've most recently been hacking on Robert Virding's Luerl (https://github.com/rvirding/luerl), working to adapt the Lua test suite to chase down some small compatibility issues between PUC Lua and Luerl. While Lua is a lovely language, it would also be swell to get Fennel working under Luerl. I wrote a game for the LÖVE jam a few months ago in Fennel and it was a pleasant way to dip my toes into lisp-likes.

I've also been adding things to control plane software, Overworld, here and there: https://github.com/saltysystems/overworld Happily all of the Protobuf and ENet stuff that I've already built nicely carries over into the LÖVE world.

An audience-driven GenAI rom-com w/ Daily Episodes.

How We Met – https://how-we-met.c47.studio/

Each day, I create a new 30-second episode based on the plot direction voted on by the audience the day before.

I'm trying to see how far the latest Video GenAI can go with narrative content, especially episodics. I'm also curious what community-driven narratives look like!

For the past week, I've been tinkering mostly with Runway, Midjourney, and Suno for the video content. My co-creator vibe coded the platform on Lovable.

SynoPosture is a posture monitoring app that utilizes your AirPods Pro, AirPods Max, or Powerbeats Pro to track your head orientation in real-time.

Whenever your head tilts past a set threshold for too long, SynoPosture reminds you to sit up and gently protect your neck, intelligently and without spamming.

## Core Features

- Real-time pitch, roll, yaw tracking via `CMHeadphoneMotionManager`

- Smart posture alerts after 5–60 s in a poor position

- Fully customizable sensitivity (10°–100° thresholds)

- Live Activities & Dynamic Island: countdown ring when posture timer is active

- Apple Watch companion app: real-time sync, haptics, Digital Crown refresh

- Enterprise-grade Anti-Flood System: 30s cooldowns, freshness filtering, pending update queue

- Full Accessibility Support: VoiceOver, Dynamic Type, high contrast, motion reduction

- Fully localized: English, Spanish, Arabic, Japanese, and more …

- Runs perfectly in the background or after force quit (via `BGTaskScheduler` + state persistence)

TestFlight Invite Link:

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

More and more people are more cognizant of their alcohol consumption, and like calories - it can be hard to eyeball them compared to the "standard unit" (14g alcohol).

I build an iOS app (https://quenchai.app) that uses a carefully constructed Multimodal LLM workflow to convert photos to standard drinks and track consumption over time.

Did you know a standard margarita is ~2.5 standard drinks and a light beer is ~0.8?

I've been digging into WebRTC to understand how it works under the hood. My goal is to eventually build a lightweight media server with SFU capabilities — but focusing on the protocol level, not just using libraries.

To get there, I'm breaking it down into smaller projects. The first one: a basic WebSocket signaling server written in Rust (based on RFC 6455). I'm also learning Rust, so this was a good way to build something real while figuring things out.

On the frontend, I used Angular and just the RTCPeerConnection API — no external WebRTC libs. The focus for now is just signaling: how peers connect, exchange offers/answers, and so on. No media or security handling yet — that's the next step.

Here’s a short demo video on YouTube https://www.youtube.com/watch?v=V_qdW2JchbU It’s not production-ready yet. Right now, each WebSocket connection spins up a new thread, but I plan to rework that using something like Tokio for better performance.

Curious to hear thoughts or suggestions.

Compiler back-end for WASM and more, but with the core at a slightly lower abstraction level than WASM and with a somewhat novel ABI.

To abstract around register file differences in different ISAs, I'm using SSA-form with spilling to a separate "safe stack". Enforces code-pointer integrity for security's sake (not unlike WASM) but extended also to virtual method tables.

"Partial-ISA migration" allows a program to run on multiple cores with slightly different ISA extensions. "Build-migration" is migration to another build of the same program in the same address space: Instead of trying to debug an optimised program, you would migrate it to a "debug-build" to attach a debugger. Or you could run a profiling build, compile a new build using the result and then migrate the running program to the optimised build: something that previously only JIT-compilers have done AFAIK.

I'm out of the research stage and at the stage of writing the first iteration of the main passes of the compiler, but now and then I've had to back-track and reread a paper on a compiler algorithm or refine the spec. It has taken a few years, and I expect it to take a few years more.

https://github.com/stravu/crystal

Crystal is a re-imagining of what an IDE means when AI drives development. Traditional IDEs are designed for deep focus on one task at a time, but that falls apart when you have to wait 10-20 minutes for an agentic task to run. Crystal lets you manage multiple instances of Claude Code so you can inspect/test the results of one while waiting for the others to finish.

Among many other things, I'm formatting many of my recipes and working on generating LaTeX to make a physical recipe book.

My son has inherited my love of cooking and baking, so we'll refine the book, add comments and photos, and eventually print and bind copies for our family and friends.

I also am hoping to laser engrave some old cookie sheets with one of my grandma's hand-written recipes. The problem I have is that it's rather faded, and I don't know yet how to make it pop for a good contrast.

A few things!

1. After hearing Cell by Pannotia, I became obsessed with trying my hand at making a bit of electronic music. I have an Arturia Keystep 32, a Korg NTS-1 and a Korg SQD-1 to mess around with, but I'd really love to learn how to capture the sound on the Pannotia's album since it speaks to me on a visceral level (album link for the curious: https://pannotia.bandcamp.com/album/cell)

2. Turning some old telephones into fun "audio guestbooks", have some additional features lined up that I am going to add (just waiting on parts to arrive), trying to improve a bit on the ones shown in this excellent video: https://www.youtube.com/watch?v=dI6ielrP1SE

3. Managed to get a blog post up recently. My work is not exactly what I would call "HN worthy" but if you need a laugh or some decent toilet reading, it probably qualifies (my blog: https://futz.tech/)

I love these threads. So many people working on so many different and interesting things. Renews my hope for the future, a bit.

I’ve been working on Lexa ( https://cerevox.ai/ ) — a document parser that reduces token count in embedding chunks by up to 50% while preserving meaning, making it easier to build high-performing RAG agents.

The idea came from building a personal finance chatbot and hitting token limits fast — especially with PDFs and earnings reports full of dense, noisy tables. Our chunks were bloated with irrelevant data, which killed retrieval quality. So we built Lexa to clean and restructure documents: it clusters context intelligently and removes any spacing, delimiters, or artifacts that don’t add semantic value. The result is cleaner, more compact embeddings — and better answers from your LLM.

Next up, I’m exploring ways to let users fine-tune the parsing logic — using templates, heuristics, or custom rules through UI — to adapt Lexa to their domain-specific needs.

I'm trying to create the best A/B test sample size & duration calculator: https://calculator.osc.garden/

It's free (https://github.com/welpo/ab-test-calculator), and it has no dependencies (vanilla JS + HTML + CSS).

Right now it only supports binary outcomes. Even with the current limitations, I feel it's way above many/most online calculators/planners.

I'm writing tests, fixing bugs, and adding features to improve the quality of a piece of financial software that transfers certain financial data on a special private network. It's way less fancy than it sounds, but I'm enjoying improving the tests and adding important security and legal compliance features. Knowing that others will depend on my hard work to keep their business financial records straight is a great reward, and I am taking my responsibility seriously.

I'm also working on learning about building software with LLMs, specifically I am building a small personal project that will allow me to experiment with them using measurable hypotheses and theories, rather than just tweaking a prompt a bunch and guessing when it is working the best. I know others have done this, but I am building it from the ground up because I'm using it as a learning experience.

I plan to take my experimentation platform and build a small "personal agent" software package to run on my own computer, again building from scratch for my own learning process, that will do small things for me like researching something and writing a report. I don't expect anything too useful to come out of it, since I am using 1.7B/4B models on a MacBook Air M2 (later I might use my 3080 but that won't be much improvement), but it will be interesting to build the architectural stuff even if the agents are effectively just useless cycle-wasters.

I’m exploring two different applications of AI for education and skill-building:

1. Open-Source AI Curriculum Generator(OSS MathAcademy alternative for other subjects) Think MathAcademy meets GitHub: an AI system that generates complete computer science curricula with prerequisites, interactive lessons, quizzes, and progression paths. The twist: everything is human-reviewed and open-sourced for community auditing. Starting with an undergrad CS foundation, then branching into specializations (web dev, mobile, backend, AI, systems programming).

The goal is serving self-learners who want structured, rigorous CS education outside traditional institutions. AI handles the heavy lifting of curriculum design and personalization, while human experts ensure quality and accuracy.

2. Computational Astrology as an AI Agent Testbed For learning production-grade AI agents, I’m building a system that handles Indian astrology calculations. Despite the domain’s questionable validity, it’s surprisingly well-suited for AI: complex rule systems, computational algorithms from classical texts, and intricate overlapping interpretations - perfect for testing RAG + MCP tool architectures.

It’s purely a technical exercise to understand agent orchestration, knowledge retrieval, and multi-step reasoning in a domain with well-defined (if arcane) computational rules.

- Has anyone tackled AI generated curricula? What are the gotchas? - Interest in either as open-source projects?

As a European missing a managed hosting solution, me and a buddy of mine are building an alternative: https://ploi.cloud

The goal is quite simple, allow developers to host their application with easy straight forward pricing. We are about to launch very soon. Everything is built on Laravel/PHP.

We are open to beta testers, so if you feel you want to test this please drop me and email in my profile.

I've been off work for two weeks to recover from surgery, and have been playing with a couple projects throughout the day between rest and physical therapy:

- A home-rolled router/firewall: Using yocto to create a distribution for a router/firewall for my home network. It started as an exercise in wanting to have more control over the security of my home network, as well as see how nice of a UI/UX I can tease out of an LLM. It's also part of a (seemingly never ending) consolidation of homelab services.

- A SNES Reverse Engineering setup: A nephew of mine is starting to get into video games and is starting with a SNES but his system broke. I'm working on helping repair the console, but am also trying to set up an effective "LLM + Ghidra + SNES emulator + image generation AI + asperite plugin" to allow him to swap sprites and text in games to add some creativity and learning to the experience.

- A personal assistant system: Experimenting with agents to create a personal assistant for our house, and seeing to what extent the agents can be helpful and how much hardware is required to run something like that in-house.

- aztui: A TUI for exploring and interacting with Azure resources. I'd like to add some caching/pre-fetching logic to make the interaction with the interface snappier (one of the main motivators to create it).

I've been using GPT pretty heavily throughout, and it has been a lot of fun both using it, and spending some dedicated time looking at the models themselves along with the frameworks that support running and integrating them.

Finally cleaned up a free online Python course: https://proficientpython.com/

I wrote the articles/exercises/projects a few years ago, but now I've made interactive coding and quiz widgets, using Pyodide, Lit, web workers, etc. All open source: https://github.com/pamelafox/proficient-python

JSON API to integrate with QuickBooks Enterprise / QuickBooks Desktop https://qubesync.com

Spent 14 years slogging through a custom implementation with my previous company, and didn't want my pain and suffering to go to waste. Just spent a few hours yesterday to replace that app's integration with my new api and got a pretty good diff:

117 files changed, 258 insertions(+), 10032 deletions(-)

I am working on building Flexprice(https://flexprice.io/), an open source monetization platform for AI and Agentic companies.

This week, we’re doing a 5-day launch week, where we’re shipping a new set of billing features every day. Github link: https://github.com/flexprice/flexprice

I just finished playing with my Shimano Di2 groupset and the e-tube app. Last year researchers revealed that a simple replay attack was possible to shift someone elses bicycle. My bike was delivered with updated firmware that is no longer vulnerable so I had to find a way to downgrade the bike. The e-Tube app only allows updating the bike, but it detects root, emulators, frida-server or changing the APK and then crashes. I had to find a way to circumvent that and use an SDR to do the actual attack

I have been working on a symbolic solution to ARC-AGI: https://github.com/nesco/DPS

Shapes are converted into trees of paths, and those trees are compressed using a symbolic lookup table

A LLM can then use those symbols to reason about shapes, and a tree edit distance can be used to group them in categories

It occurs to me that I need a separate electronics workbench, more than the 2 square feet that I can make by moving my keyboard out of the way. So, this month... my goal is to have everything set up on a workbench.

Generating an estimated $130 million per day (100 Megatokens/second) worth of GPT4 tokens at home will have to wait (plus I'd need to upgrade the power and AC in this room a bit to handle the estimated 750 Kw of power it would take)

I'm building a browser extension that turns your new tab page into a customizable, widget-based dashboard.

It started as a simple way to control my Philips Hue lights from the new tab, but over time it's grown into a daily tool I rely on for:

- Taking quick notes - Launch bookmarked websites - Quick weather updates - Track multiple time zones - Embed parts of websites using an iframe widget (with CSS selectors to isolate elements)

The goal is to make the new tab genuinely useful tailored to your workflow, not just another homepage clone.

It's still a work in progress, so i'd love feedback from anyone into productivity tools, browser customization, or just building cool UI ideas in the browser.

https://chromewebstore.google.com/detail/ejnndgifkmlldcdlifj...

https://newtabwidgets.com

I'm tinkering with a little DSL for declaring embedded in-memory databases, to be emitted as C++ code. I've noticed that I keep creating assemblages of STL containers which feel like tiny databases, optimized for specific queries and constraints: a couple of vectors with structs, some maps or sets, maybe some running totals or min/max references, all wrapped up in an "engine" object governing whatever process it is that uses the data. Wouldn't it be nice if I could declare such a thing, SQL-style, and let the machine work out the details?

There's a little inspiration from the MLIR ecosystem here, which makes heavy use of `.td` files for code generation. I want to write a schema file, defining some tables and indexes along with the queries and procedures which will operate on them, then have this compiled to a C++ header file I can include, where the schema is a class and the queries/procs are methods.

I have no idea how far I'll get with this, but it's always fun messing about with weird little languages, and I'd like to see what programming in this style would feel like.

Recently, a lot of reverse engineering. I’ve been writing them up on my blog, so there’s a growing list of technical deep dives from this year: around Letterboxd with mitmproxy[0], iOS Shortcuts deeplinks[1], the QR codes for Fitness SF[2], and binary patching some non-open source code[3]. Hopefully followable even if you don’t have as much debugging or reverse engineering experience.

[0]: https://blog.alexbeals.com/posts/extracting-letterboxd-token...

[1]: https://blog.alexbeals.com/posts/reverse-engineering-ios-dee...

[2]: https://blog.alexbeals.com/posts/debugging-fitness-sf-qr

[3]: https://blog.alexbeals.com/posts/start-process-extensions

I'm DongYoon, founder of Markhub (https://markhub.ink).

We're building a chat app that automatically creates and manages your to-do list right from your conversations.

I started this for a simple reason: I was tired of the soul-crushing 'copy-paste' work of moving decisions from Slack over to Notion or Jira. So much context gets lost in that process, and it just creates more "work about work."

Our core idea is simple: a chat message and a to-do item shouldn't be two separate things you have to keep in sync. In Markhub, the conversation is the task. It's not a copy; the conversation itself becomes the to-do, and all the context is automatically preserved.

Our bigger vision is to do for collaboration what GitHub did for Git. We’re not reinventing chat or kanban boards; we’re building the seamless 'workflow layer' on top that finally makes them work together.

We're currently in a private beta and would love to hear from HN users who feel this same pain. We’ve been fortunate to get early traction with large enterprise clients (including a ~$200k on-premise deal), but now we're looking for feedback from smaller, agile teams.

Any and all feedback is a gift. Thanks!

https://github.com/CharlieDigital/runjs

I wrote an MCP server in C#/.NET that let's LLMs safely generate an run JavaScript using the Jint interpreter.

It includes a `fetch` analogue using `System.Net.HttpClient`, as well as `jsonpath-plus`, and a built-in secrets manager.

The prime use case is working with HTTP REST APIs with an LLM. With this, you can let users safely generate and execute JavaScript in a sandbox.

https://snowsignals.com/

SnowSignals - the snow conditions forecast. I love skiing but suck at finding great snow, especially in Tahoe, CA where the snow can be finicky.

SnowSignals forecasts snow conditions to show where you should be skiing. It does this by calculating a net energy balance across the terrain using weather data as input and simulating snow metamorphosis. We started a few months ago focused on the spring freeze/thaw use case and are ramping up on the winter use case (much more sophisticated metamorphosis simulations, wind transport, etc) - in winter '25, you'll know exactly where the powder stashes are and which ice sheets to avoid.

Less guesswork and more stoke is the goal!

Vibe coding https://www.threegen.ai/, a fresh take on social media powered by generative AI. Unlike typical AI content workspaces, threegen is an Instagram-like product with these core vibes:

- Reimagined Feed: Ditched the traditional noise—see the prompt and model behind each creation, get inspired, and check out top curated models’ performance. No more digging to figure out how the magic happens.

- Template Remixing: Creators can drop reusable templates for others to remix and build on, speeding up that creative flow.

- Curated Models: Handpicked the best for images, videos, audio, and text—think Costco quality, no endless searching or tweaking needed.

- Infinite Canvas: Reworked the workflow with an upcoming infinite workspace where creators can prompt, drag, and drop to mash up content across media.

- Built for Non-tech Creatives: Driven by our AGI-for-The-Rest-of-Us mission, it’s tailored for non-technical creators to turn imagination into reality.

- Flexible Pricing: No wasted credits—top up for up to 30% extra, never expire, plus member discounts on curated top-tier voice, image, video, and text models.

Happy to chat if you’re also into vibe coding, building consumer AI.

Writing multisynq.io apps in newswpeaklanguage.org. Two game changing technologies now working together. My dream Frankenstein has finally come to life! I (re)implemented my toy application, The Chalculator, to yet another platform (the 7th or 8th maybe?) [1] I added comments to my blog _without any backend whatsoever_ [2] I built a counter app using Newspeak's Hopscotch GUI components to respond to Multisynq (javascipt) subscriptions (the final milestone) [3] 1) https://youtu.be/MPW5L1gj4Dw?si=Lms3odwQElZu_mLu 2) https://youtu.be/8gcCIaXmQjU?si=Qg2XSDu6mIhSAd9d 3) https://youtu.be/2-tZzB8MAX0?si=6nZ1nD6d4isdQd-5

Building Ongoing Things

https://ongoingthings.com

Most of my personal life updates were shared in group chats. Those chat updates were scattered, repetitive, and for some people easy to miss.

When my son was born, I wanted to start telling his story to the people in my life. I started developing Ongoing Things with a baby in a carrier on my chest.

The app is now where we share the real stuff - raising a child, a trip, a project - each in its own place that we call a "thing", with just the people it's meant for. No feed. No comments. No signup required - people need only an email to follow along.

We have a small user base, and tons of features are still missing. We are working on making it better. Our roadmap includes:

- "Partner Things" to allow few people to share updates to one thing

- E2E encryption for posts

- Customizable layout of posts

- RSS feeds

Would love feedback if anyone is interested in trying it.

Edit: formatting.

I am building https://balancing.services to improve transparency of European balancing markets.

The balancing markets are used to keep the power grid in good shape, by smoothing out any last minute mismatches between energy production and consumption.

The project started out of frustration of not being able to get this information without friction.

ADHD-supportive notepad. A distraction-reduced space for writing quick thoughts. I have two huge monitors covered with dozens of windows and hundreds of tabs. Notepad text goes to the edges of its window and is black on white, way too visually noisy, so I open a sticky behind it and give myself an inch of buffer. But then I need to look at something else and the layers get upended.

I’m a non-technical manager of a development team and couldn’t conscionably ask one of my devs to do it, so I downloaded Delphi (we are very old school) and got to work with ChatGPT. It’s been fussier than I ever imagined, but now I’ve got the minimal functions, autosave, buffer zones and color options I’ve been dreaming of, plus new insight into what my devs go through when I ask “how hard can it be to just…” Mopping up some issues with resizing. I’ll post a free version soon.

I'm building an app[1] (repo[2]) that helps you visualize perspectives and details about complex problems so that it's easier to figure what to do about them.

Right now it's basically a diagramming app specifically for the domain of problem-solving. I think an issue with it is that it's too hard for new users, so I've spent the last few weeks UX designing a view (figma prototype[3]) that I think is more intuitive to use (though sacrifices some features).

I'm currently working on code design for this view and am hoping to implement in the next few weeks!

[1] https://ameliorate.app/

[2] https://github.com/amelioro/ameliorate

[3] https://www.figma.com/proto/psTRolY8LTVOef3fkCJ0B4/Simplifie...

Look, I know it's crazy.

My own action MMORPG (think Mordhau meets Cyberpunk meets Arma 3). It's the perfect application of everything I already know as a platform engineer, and I get to learn all the things I don't. I'm making the client foss, the assets foss, and the gameplay compelling as all getout. Non-sharded, persistent world, with different lands for different real world regions. It's a type of metaverse in truth, but some of that part I have to flesh out better on the local client side where you can do whatever, but on the server there is a storyline.

I almost applied to YC because I'm at the stage I'm close to public alpha and need funding, but instead I'm planning on crowdfunding, but the release strategy has to be tops. I'm also doing things like planning on how to scale the business itself, lots of work on the over time growth profit model, etc. So basically, instead of a thousand side projects, I have one giant project where I get to do everything with my own theorycrafting - after years of being stuck doing whatever the boards/c-suite needs, it's a taste freedom and a dream.

Been working on it since 2013...

Just started this project last week and don't have anything written up or properly documented yet.

I am trying to see how far I can push AIs to do a research project in physics. I did a PhD in plasma physics a decade ago - I am using the literature survey I did while looking for a problem as my starting point.

The plan is: - Using a few research papers to ground the state of the world, see if I can nudge it towards coming up with a few research problems to tackle. The problem needs to be (1) unsolved and (2) something that is probably solvable in a timeboxed fashion. - Let the AI read more papers to refine the hypothesis, and come up with a plan. - Let another agent write code to run numerical simulations. - And finally do synthesis.

I am curious to see how far it's possible to push the models in this direction. At the very least it hopefully helps new grad students in a copilot capacity.

I'm making a public wishlist platform — https://thingstohave.app. I started it for my friends, but now have intentions to bring it to public.

I procrastinate on my plans to making it into true public-facing product. I can't make myself doing any marketing, have very vague monetization plans, miss some feature that people for some reason want a lot, and occasionally put crap into prod!

That said enjoy building it, learned a lot of backend stuff, felt in love with svelte, and, most important, me and my friends enjoy using it.

To balance enjoyment and pressure i'm trying have some small wins constantly, even if they are very low effort. For example current landing page was procrastinated for six month and built in 30 minutes. It's not fancy and good but it's better than 0!

A TV-TV video calling system (raspberry PI + off shelf camera and mic). Idea is have a more immersive experience where you can talk to entire family instead of just a persons face (or parts of face in the hands of my parents or kid). Next stage is to add games to the calls. Have some games already prototyped with good feedback from kids.

Still thinking of how, what and when to open source.

Substrata - an open-source metaverse. https://substrata.info/, https://github.com/glaretechnologies/substrata

Custom high performance C++ / OpenGL/WebGL engine. Uses Jolt physics and Luau and Winter scripting.

It's a lot of fun and pretty challenging code.

I'm building a BigQuery SQL tools. It can

- format BigQuery SQL queries better (in my opinion). Support configurations for: maximum line length, standardize casing for SQL keywords and builtin functions (upper or lowercase). BigQuery UI does support formatting but the output doesn't look as "eye-catching" as I want.

- auto converting between standard SQL syntax and pipe syntax in BigQuery. Most queries work but some are not supported (for now - only case I see not supported as query that involves star expression in a group by since it requires the knowledge the underlying column of the table to work - though I haven't seen anyone writing this kind of group by query yet during my work)

- bring all the nested CTE to the outer of the query. this will be helpful such as BigQuery doesn't allow nested CTEs inside a recursive query. (recursive CTE will be handy if you have a CTE that is referenced multiple times - in such case, you can use recursive CTE to materialize that CTE so it is calculated once)

All this is done with the help of ZetaSQL library. I've done the code but have not yet have time to create a simple UI for it yet :)

I'm working on a side-project in my spare time since the end of 2012 (before at the university) with some gaps, which is an append-only DBS with time travel capabilities using a custom storage engine based on COW tries and a (still I think) novel page versioning strategy called Sliding Snapshot. Recently I began work on pooling pages for reuse and a custom allocator for variable page sizes. Before, I had created new instances whenever a page was read from disk instead of reusing instances, so the allocation rate was really high for parallel transactions.

https://sirix.io | https://github.com/sirixdb/sirix | http://brackit.io

https://carelesswhisper.app

Locally running wispr flow equivalent without any tracking, signup, analytics or subscriptions.

Dictate into any text window on your Mac. Works really well with technical language specifically when using with claude code, cursor, windsurf.

Very fast since the underlying whisper.cpp lib is very well optimized for Metal and CoreML usage on Apple Silicon machines.

I've been working on a simple, multi-protocol, global pub/sub system. https://messagebus.org/

It currently supports subscribing, publishing, and unsubscribing in JMS, MQTT5, Redis, and Websockets, and send-only in SNS.

I'm not really sure who might use it, but it's been fun.

Working on my subscription manager to help me get an overview, and focus on unsubscribing from subscriptions that I do not need to have continuous access to.

I realized that a lot of the subscriptions I have would have been better treated as one time payment for 30 days access. Since, I often can go a few days between using it. So when the subscription expires, and it takes a few days until I use it next and decide to resubscribe, I would have saved a bit of days compared to being constantly subscribed.

It still very early development, and lots of features are missing, so wasn't sure I wanted to share it yet. It got very basic features for tracking subscriptions manually and getting reminders before renewals. Still, is testable at https://unsub.cash

I've been slowly building a website full of daily puzzle games (https://regularly.co/). I built the first game for my wife (https://regularly.co/countable) which she plays every day. Floored is my personal favourite, I find it deceptively challenging

I'm working on an ultra-lightweight data contracts framework for python dataframes (pandas, polars, pyspark, etc).

Using Narwhals under the hood has been a blast and amazingly effective!

Shifted some stuff around recently, and trying to get a guaranteed stable api so that I can bump to v1.

https://github.com/benrutter/wimsey

https://github.com/thiagoharry/weaver-interface-metafont

I started by trying to reimplement the METAFONT language, adding support for real-time rendering with OpenGL. Eventually, I decided to introduce some incompatible changes, creating a new language. But it still retains a syntax and internal logic very similar to METAFONT.

This new language also supports animation, and since it is part of a larger project (a game engine), it can be used not only for font rendering but also to generate textures and sprites for games.

The language is successfully compiling to WebAssembly, and I’m currently working on a web page with tutorials, documentation and examples where you can modify the code and instantly see the results. Since this is a literate programming project, there is also an English and Portuguese version of the code. But the english version still needs considerable polishing.

https://childrensbookforall.org

My wife (who is a psychotherapist) started this and I am helping her with this. We are using specially curated children's books as a medium to talk about social, emotional and psychological aspects of mental health among adults, adolescents and teachers. We are also building communities and support groupsaround children's books.

This is in India where talking about mental health can often be a taboo subject. People who need/want to talk about this also find it hard to express and there are limited spaces which give you opportunities to do so. We found the abstractness of children's books as a great evocative medium. They also promote play, wonder and joy - aspects which positively impact mental health of individuals.

The project started with a personal journey of grief my wife experienced (death of a parent, diagnosis of other parent with Stage 4 cancer).

Working on FilePond v5.

Entering year three of a complete rewrite. It’s kind of ridiculous but as I’m still enjoying the process of trying to built/craft a performant and flexible file upload web component I just keep going.

V4 is live on https://filepond.com, plan to release v5 before the end of summer.

I’m currently working on a sequencer DAW plug-in (MIDI, audio) with multiple voices & precise timing/articulation controls, including a templating system & transformations to apply these changes to several steps/voices at the same time. Will also support importing/exporting tempo maps.

Can be used for everything from slightly skewed beat-making to generating undulating waves of sound!

Currently building https://kidzovo.com to fix the addictive relationship that young kids are forming with screens.

The idea is quite simple, make an interactive youtube for kids. Instead of passively watching video content for long periods of time, make it interactive similar to how AAP recommends parents to co-view, we offer an AI buddy to co-view & engage kids with small interactive activities where kids find & tap on objects, speak to answer questions & more.

If anyone here has kids between 2-8, please check it out and let me know your feedback.

Oh !

An ISC-licensed implementation of several Content-Defined Chunking algorithms in Golang at https://github.com/PlakarKorp/go-cdc-chunkers

Whenever you have redundant data you want to store / transfer, this library lets you perform fast content defined chunking

I've finally come around to set on a journey to develop my first game. It followed a read on Gamedev in 2025 that actually popped on HN a few months ago[0].

I've mostly scribbled notes on paper for now, trying to be exhaustive about all that before scoping MVP (maybe SLC[1] would be better but I'm first doing that for myself so I'm not really pressuring myself for now).

I'm using modern C++, and will probably start from SDL3, plus a couple other libraries, but nothing too big or framework-y beyond that.

[0] https://news.ycombinator.com/item?id=44038209 [1] https://longform.asmartbear.com/slc/

A platform for hiring and monitoring AI agent interns

https://gadabout.ai

This was an evening's experiment turned pilot that's now speeding forward with a strategic partnership with a revenue operations company.

I was originally trying to solve user experience testing of my own projects with multimodal LLMs. The intuitiveness of these models given a browser opened my eyes to the possibilities with tooling (what we now call agents), then expanded into long-term memory and personification.

Recently found PMF in what's best described as a signal-to-outcome workflow hooked up to companies' sales pipelines.

Landing page coming soon™ - feel free to reach me at yann@gadabout.ai if you're experimenting in this field too.

Partly for my own use but largely for learning purposes, I developed a multi-platform note-taking app using Flutter and Dart. It's a bare-bones mobile-first app that stores notes as *.md files to support SyncThing-based synchronization. The UI is inspired by Android apps like Omni Notes, Material Notes, Noteless, etc., which however are either not multi-platform or not aimed at SyncThing-based synchronization. Obsidian's mobile app, in my opinion, is not as mobile-friendly as these apps. Joplin is the closest I could find but which I did not like.

It's tested only on Android 10 and Windows 11. Bring done with Flutter, it should work on iPhone, Mac and Linux too but would need building, testing and fixing various issues found.

Had I known this would take me 3.5 weeks (dedicated time) and 6100 lines of code (including comments), I would not have done it. Ideal would have been just a week.

Currently closed source.

jq Jake: An interactive challenge based approach to learning jq for JSON processing. https://jqjake.com

jq is an incredibly powerful tool, but it's not always the easiest tool to use. LLM's are remarkably good at constructing filters for most uses cases, but for people that work with JSON a lot, learning jq can be real benefit.

I'm building Talo (https://trytalo.com) - an open source backend for Godot and Unity games with leaderboards, analytics and authentication.

I've been working on making it easy to drop in socket-based multiplayer with "channels". Players can join channels and they can share messages, state updates or notifications over a socket connection. You can use it for chat rooms, lobbies/matchmaking or async multiplayer.

One recent addition is "channel storage": a shared space for players to read/write/update/delete data. This opens up saving and loading shared worlds between players in just a few lines of code.

Everything is open source, including the frontend dashboard, backend, Godot plugin and Unity package. GitHub here: https://github.com/TaloDev.

I'm building a web game, inspired by GeoGuessr, but for robotics: find the robot's axis configuration to reach a specific target.

https://www.kineguess.com/

It's still a WIP... lots missing, but happy to get any feedback!

Website where you can download lists of all registered domain names for each domain zone in the world.

Currently available: 274 million domain names across 1570 domain zones.

Domain lists are updated daily.

Download via website or via HTTP REST API.

Can be used for parsing, marketing, automation, research and whatever else.

https://allzonefiles.io

I am attempting to recreate Neuro-sama with existing trending new technologies. Quite useful now on repository https://github.com/moeru-ai/airi with over 1k stars.

Still working on the realtime, memory, and game playing part. If anyone is interested, feel free to join and build.

detecting geometry from point cloud scans of buildings using ML/RL techniques :

flat planes and edges : https://youtu.be/-o58qe8egS4

semi-cylinder pipes : https://youtu.be/8fjHNDGKeu4

Aim to automate that TAM of 5Bn/yr of manual labor, growing at 12% cagr

SOM : ~100Mn

I’m building a browser-based static site generator and CMS.

I love SSGs as they’re simple and fast and the sites they make can be hosted anywhere with little maintenance. But, after helping a non-technical friend get up and running with one, the UX is rubbish.

So I’m building a combined CMS and SSG called Sparktype, designed for writing and publishing. Users can create pages or collections, write and export the generated site. At the moment it exports to zip, but I’m working on connecting to Netlify or GitHub for automatic deployment.

My goal is to build something that allows people to create a publication with the ease and polish of say, Medium or Substack, but which is completely portable and will work on almost any hosting.

It’s very early MVP - the editor works, but the default site theme is rough around the edges and there are a bunch of bugs. I’m currently working on getting it good enough so that I can create its own marketing and documentation site with it.

I’d love any thoughts or feedback you might have.

https://app.sparktype.org

I’m working on Reflect [0], it’s a private self discovery and self experimentation app. You can track metrics, set goals, get alerted to anomalies, view correlations, visualize your data, etc.

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

Getting close to dark-launching a web-app that scans a domain for common issues - there's a heap of "performance measurement", "security analysis", "SEO scan" sites - but nothing that really does them all - a one-stop-shop if you will.

It's been a fun ride co-coding with Claude (Sonnet 3.5 > 3.7 > Code). Already it found a bunch of interesting bugs on a heap of my own sites, older employer sites, friend's sites.

Started as a simple Django web app, extended to Celery+Redis, now also leveraging CF Workers and R2 storage.

Was bourne out of an observation that some sites I have been working on missed some crucial things like domain expiration of asset-domains, mis-configured CORS or SSL certificates, http header and meta collisions, missing/wrong redirects for http/https/www/no-www etc.

I started a podcast and have been having a lot of fun talking with staff-level engineers about their passions. It’s called Interrobang.

https://catskull.net/podcast https://podcasts.apple.com/us/podcast/interrobang-with-dave-...

I built the whole tech stack with Jekyll and Cloudflare and wrote about it on my blog: https://catskull.net/podcast-workflow.html

Finally, I built a simple chat app as a web component with a Cloudflare durable object and have a few AI bots spamming the chat that may or may not ignore you: https://catskull.net/the-most-dangerous-app.html

Fostrom (https://fostrom.io/) - A developer-focused IoT Cloud Platform.

In Fostrom, devices connect via our SDKs or standard protocols such as MQTT and HTTP, and send and receive structured, typed data, through pre-defined Packet Schemas. Each device gets its own sequential mailbox for messages. You can trigger webhooks or broadcast messages to other devices based on incoming data, powered by programmable actions (written in JS).

We entered Technical Preview recently. Since then, we've been working on:

- Major upgrades to Actions: making it easier to write action code, along with testing before deploying, and more docs on how to write good actions. Coming this week.

- We're in the process of releasing Device SDKs in multiple languages, including JS, Python, and Elixir soon. The SDKs are powered by an underlying lightweight Device Agent written in Rust.

- A new data explorer to view and analyze your fleet's datapoints, which will be available in a few weeks.

Happy to answer questions and appreciate any feedback.

Building https://gemlink.app, gemlink is an Internet content collection management platform, which collects efficiently through browser extension, flexibly organizes through websites, and forms a value content network through social sharing mechanisms. It can also be used as a "Read Later" product alternatives. In a Twitter-like experience, save a content is equivalent to "tweeting" (if it's public), and if it's private, it's only visible to yourself.

Project Website: https://gemlink.app/ Companion extension: https://chromewebstore.google.com/detail/snapreader/pickciba...

I _was_ working on an open-source, self-hostable app for sending out newsletter to your friends and families. I made a MVP but then I scrapped it after realising how cumbersome it is to manage email related functionalities. Since its strictly for connecting with your friends and family, I figured, why not let users use their own email to send out the updates.

So I made a proof of concept app on iOS that uses gmail API to send out newsletter emails. I wish I could just send prepopulated emails (with inline attachments and recipients) to iOS mail client instead of asking for gmail OAuth permissions, but it doesn't look possible.

Now I'm trying to create a polished app for alpha testing. Been exploring data persistence (Swift Data, Core Data, rxdb etc) and settled on Core Data. Architecture wise, I've settled on MVVM + Swift UI. At the moment I'm trying to figure out how to make mocks and XCode preview data geneeration ergonomic.

So far, I am pleasantly surprised at Swift and iOS development, but I still hate XCode.

I am taking a slightly different route this month and working on my Half Fast DevOps writing project. Borne from 25+ years in the trenches of software development, IT, DevOps, and any number of popularized names from the past two plus decades, it is part therapy, part satire, but mainly an attempt to make my tech-writing less soul-crushing.

Most of the documentation I read seems to have been created by a sleep-deprived robot in a stand-up or by a caffeinated squirrel with memory issues. So, I am searching for a voice to bring something different to talking about broken pipelines, observability bills expanding faster than my waistline, and heroic config file linting for the impatient.

I aim to make writing (and reading) my documentation tolerable (and perhaps even FUN!). I hope to make the next person who has to read my written word laugh and absolutely confirm my clear lack of sanity.

Exploring the implementation of Dynamicland (dynamicland.org) using Guile Scheme, Hoot (scheme->wasm) and miniKanren. Main write-up can be found here: https://deosjr.github.io/dynamicland/

I cycle between learning about scheme macro hygiene and implementing more and more realtalk/dynamicland demos and trying to grok the programming model. Doing this in the browser is a weird but fun constraint that makes things shareable.

My latest project is a wikipedia explorer: https://deosjr.github.io/dynamicland/wiki.html

I'm working on Alis Studio (https://github.com/alphatica/alis)- software to manage portfolios and research stock market ideas.

It's an MVP but perfectly usable. I needed features that I couldn't find anywhere else:

Parameter optimization with a genetic algorithm

Fuzzy optimization: randomly remove trades or whole markets and see what happens

Data mining: find rules how to exit trades sooner for better profit

Compare strategy results to random trading

Check current drawdown for statistical significance

Write trading systems in Java so I can test every idea under the sun and never be held back by some custom "scripting" language.

Of course, it's open-source. A GitHub star is much appreciated. Thanks!

I’m working on a help center that keeps itself up-to-date - https://happysupport.ai (landing page is German, product is English)

Creating and maintaining an up-to-date help center is a huge hassle. In many companies there is no one that really feels obligated to take care of it.

We want to optimize this process:

- Creation: Just click through your process. We take a screenshot on every click and generate a full written article with screenshots and a GIF. You can also talk while recording to add additional context.

- Maintenance: Connect to your tools (GitHub, Asana, Slack, …) and we automatically suggest changes to your docs if your product changes.

- Consumption: Users can consume the content as they like: Read the docs themselves or ask a Q&A bot.

At the moment the creation and consumption parts are already working well. Now I’m working on the maintenance part.

https://selectube.app/ Working on curated YouTube for kids. Trying to make a place where my kids can watch the good stuff without getting sucked into all the mindless junk.

Also it’s been a fun excuse to try out Cursor and other AI tools I don’t normally use in my day job.

I have 1 user - my 8 yr old son.

I've been working for some time on a voxel building environment which uses irregular voxels (cellular voxels) instead of the usual cubic grid ones.

If you're curious, you can see it here (needs WebGL2 + Wasm):

https://jazzprogramming.github.io/vorfract/

I've started creating algo-generated music based on realtime bird detections. This is my first time putting music out and it was a pretty easy process to go through. About $24 and a WAV file will pretty much do it through the major distribution channels. Do not expect to see any money, but still fun to experience the process and to be able to ask Siri to play my music.

  - https://music.apple.com/us/artist/birdymusic-com/1819583178
  - https://open.spotify.com/artist/28Jh4B0lVKVVWbVUvgpGTk

I have some friends who were laid off and are on the job hunt. We were all quite surprised to learn that LinkedIn does not have a "view jobs only at companies where I have connections", so I built https://jobsbyreferral.com/

It's powered by https://rapidapi.com/letscrape-6bRBa3QguO5/api/jsearch, which is a little pricey, so I'm trying to decide whether to put more effort into the project (I'd have to charge _something_ to offset the costs).

I adore Geoguessr, but when I play it I wish there was a bit more strategy, or a longer term planning aspect to the game instead of purely memorization and clicking.

So I'm building it. Still early, and I have nothing to share yet, but I'm already pretty confident my Geoguessr friends will love it when it's finished.

A simple “ChatGPT for email.” I just want to be able to ask things like “What time is my flight next week” or “Can you pull up the email where I sent John the final documentation for the api?”

I don’t want to auto compose messages or anything. I just want the computer to filter out things I don’t care about and tell me the answer to things without hunting around my inbox.

Working on `plakar` (https://github.com/PlakarKorp/plakar) an opensource backup utility and all of its related libraries and tools :-)

We've recently released a new archive format called ptar, it can be found on HN if interested :-)

I am working on a babelfish ie speech-to-speech language translation for use during vacations namely Tokyo Disneyland where you can't ask the speaker to stop speaking. I am kind of surprised that it does not exist yet. I want it to be like this this video where the app/device talks in English in realtime over the Japanese speaker https://youtu.be/PfPC4KEdTDY?si=h4BfmkNvQnmOzvgC&t=62 however I found no iOS app that can do this yet, they all require the speaker to stop speaking before translating. I know Google translate can live speech-to-text but I'm wondering if I can achieve speech-to-speech with earbuds and a shotgun microphone so I don't have to look at my phone. and there's new iOS on-device models so I'm hoping I can get better offline accuracy

Figuring out the plot and character designs for the next chapter of my graphic novel about a utopia run by AIs who have found that taking the form of unctuous, glazing clowns is the best way to get humans to behave in ways that fulfil the AI's reward functions.

http://egypt.urnash.com/npol/

And moving my financial support for this graphic novel over to a new crowdfunding platform that's run as an employee-owned co-op instead of a for-profit affair with a lot of VC investment that's starting to demand more and more attention to turning a profit.

https://comradery.co/egypturnash

I am close to releasing an iOS Camera app (yes another one lol) called Invisible Camera. It's a minimal app that works the way I like to shoot with my Fujifilm camera: focus on what I see, quickly apply a look / filter with a slider and shoot. The processing pipeline reduces the default color science applied by iOS to result in a more pleasant look.

You can join the beta https://testflight.apple.com/join/LEJk313o

When I can, I am also working on some features for https://midicircuit.com Beta here - https://testflight.apple.com/join/pNyAUEac

I’m working on LearnMathsToday, a mobile app that helps students learn math in a fun and engaging way. It’s self-paced, with AI-generated questions that adapt to each student’s level. One unique feature is AI-powered marking, which gives instant feedback on written answers. I’ve also added gamification—points, levels, and a storyline—to keep students motivated. Right now, the app is based on the Singapore syllabus, since I’m based in Singapore.

Feel free to download here:

https://apps.apple.com/app/learnmathstoday/id6740993744

https://play.google.com/store/apps/details?id=com.learnmaths...

https://learnmathstoday.com/

https://www.abareplace.com/

An old-school regex and text processing tool for web developers. Great for browsing source code, automating complex replacements, and decoding Base64, URL encoding, or Unix timestamps from your clipboard.

I'm working on a neighbourhood analysis app. It gives people looking for a new apartment or travelling to a new city all the information they need at a glance. I ingested a lot of public info into a database and combined it with routing services to provide a simplified analysis of any spot. This includes local infrastructure and amenities, quality of public transport access, distances to the city center or your workplace, demographics and more. One thing I wanted to make sure is to keep everything local, since those API calls can get very expensive very quickly. I am learning a ton here.

I'm currently close to the public release. After that, I want to learn some ML techniques to predict Pieter Levels' Hoodmaps classifications from my publically sourced data. It would be cool to have accurate automatic predictions of the places-to-be for every city.

I'm building StaticBot.dev. I was surprised how tedious the manual setup for hosting static websites on AWS infra still was after 2 decades in the industry, and as I wanted to put a few websites out there to test waters for some ideas I had recently, decided to tackle it myself. So basically scratching very own specific itch: deploying and managing a fleet of static project websites in AWS infrastructure with IaC and nice UI. I wouldn't myself use something with (hidden) vendor lock-in, so opted for "hybrid" approach where user can deploy conveniently using the tool but has up-to-date terraform code avaiable in s3 so can take over project deployment anytime. Not much of a business mind so I might open source the whole thing later on (though the value of code kind of plumetted lately as AI can generate it so well).

As the next Advent of Code is still 5 months away, I decided to build my own programming puzzle game: Marches & Gnats (https://mng.quest)

It's a browser-based game where you solve challenges using a Turing machine and eventually create a higher-level programming language on top of it. The story is set in 19th-century Estonia (so hopefully you'll learn something new about my country's history along the way).

I built it with Django and django-unicorn.

https://resample.app

A simplified DAW for mixing together tracks with different keys and tempos. It uses WebAssembly and emscripten under the hood for audio processing.

It’s a work-in-progress passion project of mine where I get to explore new technologies and hone in on my UX / Web a11y skill set.

Aside from games (my job is indie game developer) I’m working on a pixel art app for macOS “Dottie” https://bsky.app/profile/gingerbeardman.com/post/3lqxc3jwqss... that leverages my learnings from years of research https://news.ycombinator.com/item?id=41136905

And I’m looking to productise a bookmarking app “Tsundoku” I built for myself and have been using for a year https://bsky.app/profile/gingerbeardman.com/post/3ls2ymul33s...

Still working on my video game.

I didnt realize how much overhead an sfml window draw call has, granted I have yet to target optimizing that yet.

Seems like my first candidate for multithreading; also I think the scheme I implemented for how to manage texture/sprite switching is advised against and may need to slightly refactor how I store and swap based on object state.

Yeet

I'm working on TokenDagger [0] a high performance implementation of OpenAI's Tiktoken. My benchmarks are showing 2-3x higher throughput, as well as ~4x faster tokenization for code samples on a single thread.

[0] https://github.com/M4THYOU/TokenDagger

I’m working on Great Rift Safari — an AI-powered platform that helps travelers design fully personalized safari itineraries in East Africa (think Kenya and Tanzania).

Instead of wading through endless lodge options, park fees, and confusing seasonal details, you just share your interests (big cats, birding, photography, budget, luxury, etc.), and our AI planner (plus input from local experts) builds a detailed, day-by-day itinerary for you.

We also show realistic price estimates and handle all the local logistics, so you can focus on the adventure, not the spreadsheets.

If anyone here has struggled to plan a safari (or has feedback on what would make it easier), I'd love to hear your thoughts!

Website: https://www.greatriftsafari.com