Ask HN: What are you working on? (November 2026)

I’m still looking for work in the mean time but I’m proud so far of what I’ve achieved.

https://getcrewbird.com/

The theme is an empty Earth. All natural Earth with no human constructions (until the players start playing and occupying it).

Using Rust and RocksDB.

eremoterra.com

University of California San Diego has deployed our Wayfinder and Waystation web apps for their 35,000+ students!

We’re getting ready to launch our Vehicle Positions software, which replaces expensive, proprietary vehicle location systems with free, open source software that runs on commodity smartphones.

Our next-generation server software, Maglev, is adding support for newer transit data formats, like GTFS-Flex so that we can show demand responsive transit systems on the map.

We are always looking for more developers, biz dev, ux designers, product managers, and more to help out!

Open volunteer positions: https://ossvolunteers.com/organizations/open-transit-softwar…

Our software: https://github.com/OneBusAway/

More about us: https://opentransitsoftwarefoundation.org

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

The original goal was an alternative to ChessBase, but with an Apple-native GUI and iCloud sync between devices, and as an improved alternative to tools like chessbook.com for operating repertoire management and spaced repetition opening memorisation. In recent months I have focused more on the chess-playing parts of the app, trying to implement human-like computer opponents at all levels, using a transformer-based model (similar to the one described in the Maia 3 paper) combined with a very small search.

Recently I’ve also been working on chess variants. Since a while, the companion Apple Watch app plays 5×5 chess. More recently, I added a 10×10 chess as an Easter egg game inside the app, and I’m now working on hexagonal chess. With the current state of the art in computer chess, it’s almost trivial to implement vastly superhuman strength in all these variants, but implementing weaker levels that are enjoyable opponents is interesting and challenging. Unlike in normal chess, there are no big databases of human games to train on.

Also, creating interactive ways to view the experiment and visualizating the results.

https://crux.lakin.dev/eval

Send your beacon to a group, and everyone gets a gentle ping. The first person who answers gets connected for a 1-1 call, and for everyone else the signal drops silently. It does not log any missed calls so there’s neither pressure to answer nor pressure to return calls.

Overall it works really well! It’s best if you’re able to join with 4+ friends/family you’d like to chat with more. I have dozens of connections in the app now and it feels like absolute magic to me. I tap the button to send my beacon to everyone and get a random friend on the line.

https://trybeacon.chat/

https://santawho.com A funny holiday game you play in person with the whole family on just one phone (the parent interviews everyone for jobs on the North Pole and surfaces inner insights about what everyone might enjoy from Santa). It’s for any age, private, ads free, just pure holiday spirit.

https://www.dreamlist.com – collaborative shopping lists and online wishlists and gift drive platform. Again ads-free, private, stack multiple lists into groups of lists to share on social media or with grandparents.

A number of other ones about to launch as well. All little tech, not big tech – private by default, no ads, no feeds or media, just surfacing what is needed.

Now we don’t deploy this to private companies except some gov projects. But we are engaging existing IaaS and dedicated servers providers. Later hope we would fight with Broadcom and IBM 🙂

We previously ran a services company that built over 100 private clouds, then decided to turn that experience into a product with an aggressive level of automation to let DevOps, SRE, and platform teams hit a 1:300 ratio per developer (now dev + AI agent teams).

We are currently deployed across 12 datacenters and raising our seed round this month.

Regarding been curious, today I have created my first explainable video with Remotion +claude so if you want to see open edit results check https://promo-review-shalb-promo.stage.kube-dc.com/

Would be glad if you comment. Thanks!

Here’s a demo: https://non.io/video/linen-demo.mp4

As a disclaimer I cut 32 seconds of generation time out of that video, but still I’m quite happy with the speed. Not launched yet, but it’s been fun to work on / wanted to show off progress 🙂

Project #1: I’ve been working on migrating an application [1] from GCP (where I pay $200/mo to host it) to a physical server (PowerEdge R7625) I’ve racked in a colo near me, running on my own IPs/ASN [2] and all that jazz. I’ve been dragging my feet on the this as there’s just a lot of moving pieces, but I got a good chunk of the last few hard bits done today.

Project #2: Building a DIY bright-ass lamp, like Brighter [3] or Rhythm [4], but for a few hundred bucks instead of $1-2k. I’ve specced out the parts, designed the hardware, and built the firmware. Later today I’ll do my first LED test against a bench supply, to get some hard numbers for if my cooling solution (a chunky aluminum heatsink and some Noctua PC fans) is sufficient for the full 500+ W final version.

As far as curiosities go, I’ve been doing a lot of Go (the board game, not the language) puzzles, and reading about sailing (mostly the book from the Hundredrabbits folk [5])

[1] https://abound.art

[2] https://bgp.tools/as/55078

[3] https://getbrighter.com/

[4] https://www.betterwithrhythm.com/

[5] https://100r.co/site/busy_doing_nothing.html

– removes the stuff that I don’t care about (Firefox sync, VPN, etc.)

– fixes a lot of the awful UX/UI choices that the (frankly) incompetent product team at Mozilla refuse to

– actually adds stuff that I do like integrated mail and calendar, a document library system (basically Notion), native ad-blocking, terminal, task-tracking like Trello, time-tracking like Harvest, etc.

– has integrated AI (Apple intelligence for MacOS for the easy stuff and Claude for the hard stuff

It means that instead of having half a dozen applications open, I can just work within my Firefox fork. Because it’s all deeply integrated, I can do wild stuff like:

– tell my AI to search the web on a schedule and send me a custom daily brief with my own email

– maintain a comprehensive memory of all of the work that I do, across half a dozen clients, and be able to query it easily

– pull analytics from multiple web dashboards and format them into something cohesive

– program the web with a node-based infinite canvas that has live websites as part of the workflow

– manage my tasks across multiple domains (for example, it will see that I sent an email to a client and automatically update a task that says that I need to do that)

It’s incredibly powerful and it has made me much, much more efficient.

I make a special `textual DSL` where I model business scenarios like `Make a sale that include 3 invoices : 2 to different cities in country A in currency USD and other in country B in currency EUR` + all the intermediate steps like transportation, manufacturing, etc.

I`m now in the woods with a simplification for the price engine, I dislike much how complicated is normally, and I think I have good enough solution for most cases that generate without dynamic calculations.

Product: webfrolic.com

Demo: demo.webfrolic.com

What it is?

Consider Okta (Workforce identity)+ Auth0 (Customer Identity), Authzed (authorization) + ServiceNow (IT service Desk) + Zendesk (Customer Support Desk) architected together

Being an engineer there is this inherent habit of prioritizing correctness over marketing so I would not oversell it, though its probably the most secure and complete thing that could be built from identity perspective

Status (WIP):

1. I am still debating/settling on how to incorporate the AI Agents needs into the architecture, big focus on avoiding the creation of security or performance foot guns where administrators leave room open for abuse with configuration despite all this attempt to build secure system

2. Feature stress testing and performance testing

Each game tick is an hour and games can last over a week. I got hooked on both Subterfuge and Neptunes Pride and always wished there were some more titles in this genre.

Currently in closed alpha.

https://ashdomes.com/

I’m Canadian but I moved to USA to work for Microsoft. One thing I liked about the USA was how easy it was to order bloodwork/lab testing. My original idea was to bring that experience to Canada, but since starting I’ve found other ways to improve the patient healthcare experience in Canada too.

My company is https://teletest.ca

Still not sure where this is going as the space is super crowded and moving fast, but it’s solving a lot of my own problems and doesn’t rely on third parties to run.

[1] https://colliepwa.dev

I needed a code-first approach for making installations and interactive art. MaxMsp gets messy with very big projects. Python didn’t really work well for music making and Tidal/Pi/Sclang are only meant for sound. So I needed something that has bpm synchronized threads, but can draw and do anything else like file IO, networking, hardware control etc. It works quite well now.

https://shopspec.io

What I need is something to switch the account where the usage is taken from, not the configuration.

I made something simple & transparent named Switcheroo: https://github.com/FTCHD/switcheroo

Works with other AI CLIs like Gemini, and other various CLIs like Vercel (if you’re managing multiple accounts like me), Netlify, Github etc

“Yes, OpenAI explicitly supports having multiple paid ChatGPT accounts. Each account has its own subscription, conversations, and usage allowance.”

The interesting I noticed is that in the process of curating and organizing my photos, I stumble across memories and moments that I had completely forgot.

Development Challenge: The app does two interesting things underneath the hood… First, given an arbitrary number of thumbnails with different aspect ratios, it finds the best sized rectangle that completely fits all the photos. This allows me to recursively stitch groups together and always output a rectangular thumbnail for the group. Second, the pinch/zoom UI uses these nested thumbnails directly without slicing/dicing to fixed sized tiles.

When playing Zwift, Rouvy, etc, I find that I get too competitive and ruin longer workouts by trying to keep up with or sprint past people who are much faster than me over long distances.

This is bad for building stamina and endurance, but I get bored, and it’s hard to fight boredom and physical strain both at once.

I do not get bored sitting in front of Balatro, Raccoin, Tetris – anything with bright colours and satisfying noises and combos.

The first finished prototype game is very simple: you sort coloured marbles. Higher watt output from the bike means marbles are blown, by wind, upwards as they roll across the screen. Lower watt output means they fall. Steady watt output means they move horizontally. Marble goes into correct hole -> satisfying noise. It rewards steady watt output over time, with minor adjustments, which is what I’m trying to work on right now.

I was pretty amazed by how engaging I found it (total iPad baby brain). The miles really fly by – I get tired before I get bored.

I think that next I’ll either do a tower defence game, or a less-dopamine-rewarding game in the style of Kerbal Space Program. Taking your actual weight and watt output, putting a bike with wings into a physics engine, and the gameplay loop being unlocking increasingly large airplane pieces, and designing – then flying – increasingly ridiculous airborne bicycles seems like a compelling idea, though less good for fitness.

The control surface being so limited – essentially one measurement which can either go up or down – is a really fun constraint for creativity.

I’d love to try a similar approach to gamifying exercise on a smart watch. That’s an even more fun problem, because (when running, for example) you don’t even have a constantly-present screen to communicate dopamine to the player with. Perhaps some watches wouldn’t even be able to provide sound feedback? I’ve never owned one. It’s a really interesting constraint for game design.

The serverless MariaDB is important because it can scale to zero, so you have dev sites that cost less than $0.50/mo.

Also added MCP and CLI tooling that exposes all of the infrastructure + WP CLI + DB so agents can develop WP sites… which is nice because you can still use the WP admin interface, while using AI to develop the site, debug it, change pages and posts, etc.

Meli: A spending tracker for Mac designed with privacy in mind. Turns credit card alert emails into spending insights and budgets. I was in security for 15+ years and I built it because I didn’t want to use Plaid or other aggregators and wanted my financial data locally on my device and not in the cloud. Spreadsheets required a lot of work to maintain so I wanted some sort of automation. Connects directly to your email (reads only alerts from supported senders) and all parsing happens on your device.

Works with seven major US banks (AMEX, Capital One, Chase, Citi, Discover, Bank of America and Wells Fargo) plus PayPal and Venmo.

Does this list cover most of your spending? If not, which banks or cards would you need?

How do you get programmatic access to your data?

However, most banks do send alert emails when something is charged to a credit/debit card. Meli connects to your inbox read-only via OAuth (Google and Microsoft) or IMAP for other providers and reads those emails on your Mac.

Of course there are limitations to this approach, you only get access to the data that is available in those emails like merchant, amount, date and account.

Which banks are you interested in? Are you based in the US?

I thought I’d get where I wanted much faster, but it turns out I ran into quite a few challenges: it’s quick to build something simple, but it takes much longer to get a reader that’s robust and pleasant to use (extraction, parsing, security, infrastructure, etc.).

On the tech side, I’m using my usual stack, Laravel and Livewire, with some Python for extraction and Go for the email infrastructure. This month I’m working on the beta release, since several people around me were already using it, so I’d like to gather more feedback.

I got overwhelmed by walls of text of parallel Claude Code sessions. This limited the sessions I could steer in parallel to maybe 5 or 6. I knew there had to be a better way, and I found one: A canvas per project. Work laid out as cards. An agent in a worktree per card. Chat condensed to WhatsApp-style back and forth, not a litany of tool calls. Result is usually a narrated demo video that I can comment on by voice to have the agent go another round. Remote-control from my phone. Remote workers to scale beyond my machine. Everyone I know who tried it has stuck with it so far.

https://github.com/sadilek/obeya

It uses an allwinner T113-S3 SoC and the Quectel EC25 LTE module, and I’ve made sure voice calling works over LTE, at least on T-Mobile in the US. (this is tricky bc of carrier rules)

video and photos of MangoPi test setup and my board layout here: https://constcast.org/n1100c/

It’s been getting a decent number of sign ups despite me not really posting it anywhere or doing any marketing.

Ultimately a fun project, and useful for myself and a few friends, so I’m happy others are even interested in trying it.

I’ve started to regret using Phoenix LiveView, as it’s only deployed in one region, so high latency far from there. I’m exploring a SPA as a better alternative.

Otherwise, I’ve been playing around with a Lua engine to build feeds for websites that don’t support them, using AI to build the Lua as a once-off. It works reasonably well, but isn’t ready for prime time just yet.

Then also HNowledge[1], a free iOS app for browsing the HN stories and comments I’ve upvoted. Made it to fit the way I browse HN, which is upvoting mainly what I find interesting and may want to come back to. The app lets you browse by date, domain or score, add notes and export. Apart from syncing your upvotes from HN, everything stays local without any tracking.

[1]: https://apps.apple.com/us/app/hnowledge/id6813417548

Wanes[2], an Apple Health logging interface for tracking how long symptoms last. I tend to have headaches quite often and the way Apple lets you enter that data is pretty limited, so I created an app which starts a Live Activity for one or more symptoms using widgets, Control Center or Siri. You can change the severity rating while it runs and stop it from wherever you are on your phone (Home Screen, Lock Screen, Dynamic Island, Siri).

[2]: https://apps.apple.com/us/app/wanes/id6811679904

https://react.breaka.club

Because I can. Well, let’s be honest: because LLMs can. There’s nothing particularly novel about this. It’s just wiring a bunch of libraries together. Certainly would have been time consuming, but not difficult, strictly speaking, since all the heavy lifting is done by the libraries utilised.

Likely going to migrate https://breaka.club HUDs and editor UI to React since Godot control nodes are by no means impossible to work with, but somewhat cumbersome.

EDIT: Oh, will be open source like a lot for Breaka Club’s other libraries very soon. Still optimising.

It scans your codebase, turns it into permanent c4 & sequence diagrams and keeps them up to date on each commit. Then, instead of reviewing a 10k line coding PR, you review a 30 line change to sequence and C4 diagrams.

npm i -g @archme/cli && archme init to run it on your own computer, code never leaves your machine.

It’s a free job site with some resume tools bolted on. Lots of people from all over the world are using and that feels great. It has 2.7M+ jobs and automatically removes any job older than 7 days. We never allow reposts because, frankly, the job market is a nightmare and any job that has been up for 7+ days almost certainly has 1000+ applicants already. You’re just feeding your resume into a wood chipper.

Come and try it. It’s awesome.

I have a PAL-2 [1] (a modern KIM-1 re-creation) and started learning 6502 by entering programs from The First Book of KIM [2].

I wanted to be able to compile/link the assembly from the book so leaned on Claude to set up a 6502 dev environment for my Mac. I put everything needed (and instructions) on GitHub [3].

(Claude also has been helpful in re-formatting the 6502 code from The First Book of KIM into a more modern style compatible with modern assemblers. A few of these modernized programs I added to the GitHub repo above.)

As it happens, I am also fixing/formatting The First Book of KIM by recreating it in a modern page-layout app (Affinity Publisher). The PDF scans that are out there are not pretty, have OCR errors (and the book itself has mistakes). Hopefully I’ll have a new version of the book/PDF out on the internet by the year’s end.

[1] https://www.tindie.com/products/kim1/pal-2-a-mos-6502-powere…

[2] https://archive.org/details/The_First_Book_of_KIM/

[3] https://github.com/EngineersNeedArt/KIM-1_Development

It’s so amazing to have the ability to gather and parse publicly available scientific data and actually visualize it in real-time. It’s one of those projects I’m learning a lot from and can keep going with (the universe is a big place :)). As a software developer for 20+ years, its been mind-blowing and often also frustrating to have Claude generate code that I deem good enough. About half of my time has actually been spent on refactoring, building quite some skills in guiding LLMs in the process. I guess that part still hasn’t changed in a growing codebase.

The loop is stable and responsive when receiving from 17 to 29.9999 Mhz, but not much below that… Almost got it

Other than this, I’m playing with vibe-coding stuff I always wanted to do but never had the time/skills to do. For example, I built a TUI on top of beancount that is tailored to my needs and my business[2]. I also completely got rid of self-hosted plausible and umami analytics, and replaced them with vibe-coded built-in-rust (c) analytics tool that relies on both js-beacon and streaming of caddy access.log. Will probably publish about it in my blog soon, so subscribe to the RSS if you want.

Lastly, I’m messing with self-hosting. I completely ditched Github and Gitlab for self hosted forgejo + actions runner. I set up proper backup plan for everything I care (documents, immich library, my SaaS DB, and the forgejo repositories).

[1] https://justfaxonline.com

[2] https://kudmitry.com/articles/after-14-years-i-finally-built…

I’ve been trying to improve agent knowledge over a codebase, and existing approaches weren’t giving the result I wanted, and I wanted to keep it simple. In the end, I added a semantic layer on top of an LLM Wiki and it saved 30% of token usage in multiple benchmarks I ran. It also adds some nice features to deal with concurring agents updating the shared memory, to ensure all information there is reliable and fresh.

It’s published to PyPi, so an “uv tool install wayfinder-memory” already does all the work, and it’s compatible with almost all Harnesses.

To be honest, I started this because Postman and Insomnia became forced-corporate-cloud not usable for me anymore, and Bruno lacked a feature I considered fundamental for my workflow.

The feature is to remember the JSONPath expressions between requests, a feature that Bruno has implemented already.

But I created this thing and I’m using it daily since then. C++ and wxWidgets, it uses 40MB of RAM, and it is super fast, instead of the 400MB used by the above mentioned programs.

https://www.apikulture.com/

I’m a software developer and watercolor painter so my goal is to use real world painting techniques and have the results feel and look real.

Modeling the physics of paper, brush bristles, pigments, water, color mixing, drying in real time using gpu.

Built in rust using wgpu.

Currently looking for iPad beta testers if anyone is interested (supports Apple Pencil or finger).

https://puddlewatercolor.com

1. FormBeep(https://formbeep.com) at $38 MRR now – A form to Whatsapp tool. Stack is mainly CF workers with Clerk Auth.

2. SlashLink(https://slashlink.app) $0 – A simple pay as you go amazon link localizer. Great for affiliate folks and a cheaper alternative to Genius. Stack is same, CF workers with SQLite(D1)

3. StackStats(https://stackstats.app) $791 – A better advanced analytics app for Substack writers, fully local. I have been writing on Substack for a while now and their analytics suck!

Apart from that, running a travel agency I’d never be able to without agents (they manage my ads, social media, website content etc.). Started with boa.ba and it went quite well, now preparing dobosnia.com

There are more things I’d like to do with the graph concept, like linking two user’s recipe trees if they were imported via the same URL. Really trying to to avoid features that I think would be cool that don’t provide any functionality.

There are still a few features I’d like to implement that are more in the vein of nice to have in any recipe application, like nested recipes, temperature conversions, volumetric ingredients amounts to mass conversions, etc.

But I’ve been using it for new recipes and converting my old recipes I have written down in the margins to this format and I’ve been happy with how usable its been in these early stages.

[0] https://grainofsalt.app

github.com/patrickjh/ssa

https://cratediggr.com/

Artists make users jump through hoops to like, comment, repost etc.. before giving them access to the download – CrateDiggr highlights the free downloads in the Soundcloud UI and clicks through the download gates for users.

Been a fun passion project, check it out if you download tracks from Soundcloud!

It is New, Experimental, Modular, Declarative, Event Driven and Reactive. It builds cross-platform apps that can be compiled for the terminal (macOs, Windows, Linux), a standalone native window (macOS & Windows 11), or the browser (via WASM) from one unified code base.

Curious if this project will ever be 90% done.. 😉

https://github.com/maxmart/hoststray

Also it forces your browser to “flush” their DNS by killing the keep-alive connections that for example Chrome keeps open in background. And it can be controlled by your local coding agent through a simple API (which also serves the skill for it)

I’m kinda leaning towards vibe coding my own GUI coding agent. I currently use Pi and recently have been playing with Herdr and Paseo, but none of these feels right to me. These are amazing tools, but ai think we could do better. But I’m very hesitant – I know the only way to “succeed” in a project like this is to write (vibe code) hundreds of thousands of lines of code and it’s kinda depressing.

[1] – https://spill.rs

Now putting it to personal use and keeping an eye out for issues and rough bits to smooth over.

Built with –

NestJS, Sequelize + SQLite, OpenAPI, and Jest

React, TanStack, Shadcn, and Playwright

Also trying to replace own Duolingo usage with Fika Lingo (https://fikalingo.com) basic idea was to first repro the practice of matching words. There is now few other types of language / vocabulary practices. The practice generation works on-device with local LLM, you can give the topic yourself like “Words that relate to Hacker News”. Downside at the moment is that English needs to be the counterpart of the practices. Cant guarantee good enough quality with something like germany <-> italy practices. I’m trying to do finetuning with LFM models to see if it would be feasible to improve the local practice generation.

Since the last time I posted on HN I’ve added 100s of cinemas, user features like being able to save search filters, movies, and specific showtimes. Also a ChatGPT plugin which allows for searching for movie showtimes using natural language directly inside of ChatGPT (https://chatgpt.com/plugins/plugin_asdk_app_6abfdc298c208191…).

Finally I’ve added AI search to the site as well, allowing for natural language search with queries like “English audio showtimes near Shinjuku tomorrow” and so on.

I would really appreciate feedback for things to add, things that are hard to understand, and anything else!

the plot: Programming languages existed as an abstraction for humans. As writing code becomes cheaper, we can write it for each architecture as long as the specification is done well. The costs of running will matter more in relation. So don’t make your AI write rust, but assembly

Along the way I ended up adding an internal agent framework to satisfy stuff like “log in, click the button, and then take a screenshot”, out of which fell stuff like automatically generating Playwright tests from that. It even runs the Playwright test suite and Puppeteer test suites ( a bit faster, and for a lot less memory ). I kinda love this bit because I can layer in multiple models that will bounce control of the web session between each other, to do stuff like let a Typesafe model choose to escalate to Opus when it needs higher minded behavior. It’s fun to watch it happen.

I’ve mentioned it a few times around here, I’ll probably do a Show HN soon when I feel like it’s ready for that. Hopefully soon.

[1] https://zshot-app.com/

I’m at the point where I’m finally actively using it to register my activity, it is straightforward to register tickets by sending them to a telegram bot, then, reconcile those by uploading my bank statement.

I’m trying to get the lowest possible usage friction so that I keep using it.

So far the better built pieces related to the data ingestion. Once this is good enough I’ll build reports + anything coming to my head as a useful piece.

I’m leveraging AWS textract + bedrock + bda to parse bank statements. I expected this would have been easier but it is still a very complex problem which had required me to put many iterations (so far it works nicely with my own statements)

For ticket parsing, AWS textract + parsing rules has been enough.

I wrote a bit more on my blog https://alexitc.com/blog/2026-10-16-opensourcing-my-expense-…

Repo at https://github.com/AlexITC/expense-tracker/

Lately we’ve been working on access for AI agents. A lot of people want their own agent to do the repetitive part of time tracking. Control remains important, which is why we rebuilt our core this month to support change history and full undo/redo functionality. Feel free to try it with your own agent.

We built this after the timesheet tool we paid for raised its prices and moved some features that we used regularly behind more expensive plans. We had to add three new colleagues, and everything combined this would cost us $500 a year more for the same software.

We run Elixir and Phoenix LiveView on a Kubernetes cluster made of Talos instances.

We’re still looking for feedback on the product, so please let us know what you think!

A simple EU static and app hosting service: PodBy [2]. It was launched last week, and is at €10 MRR.

Thank you for asking and for your suggestions!

[1]: https://uruky.com

[2]: https://podby.com

It combines nonograms with crosswords, requiring both logic and word knowledge to solve. I am still working on the interface and tutorial, as well as the puzzle difficulty levels.

been curious about the intersection between observability, SDKs, and product analytics. i couldn’t find anything around SDK observability so built this little tool. curious what yall think!

i assume at bigger orgs there is some internal handrolled tool like this that ingests datadog/sentry/whatever info…if anyone plays around in this space and has feedback id love it!

I’m a product designer by trade and learnt to vibe code on Claude about a month ago now. I was weaning my baby and he developed a rash and haven’t been able to work out what the pattern was causing it. So I created an app for weaning parents to log the food, add any reactions so when talking to their GP they can start to see a pattern and all advice, like nutrients, food variety, how to serve food all coming from the NHS and FSA.

Currently got 12 mums using the app and would love any feedback to make it even better! <3

https://apps.apple.com/gb/app/niblet-weaning-diary/id6822680…

https://getniblet.app

Most planners treat your schedule as fixed, so the moment a meeting runs long or a task takes twice as long, the plan is wrong and you either fix it by hand or give up on it. In Ember, if you move a task or change how long it takes, everything after it shifts later, and it flows around fixed things like meetings. It’s been super helpful and I have been adding new features ever since.

Right now I’m working on a native Kotlin app to replace the current one is web + Capacitor and exploring full duplex voice models so I can add or move things around the app while having a conversation with an agent.

homepage: https://emberflow.space
demo: https://demo.emberflow.space/?ref=hn

I’ve got 40k+ photos on my iphone, and wanted a better way to interact with them. The basic idea I had was to virtually stitch all the photos together into a gigapixel image, and navigate that image with pinch and zoom. On import, the app hierarchically groups photos based on date and similarity. The user can go back and edit the groups, change the layout, and adjust the size of photos if they choose.

The interesting I noticed is that in the process of curating and organizing my photos, I stumble across memories and moments that I had completely forgot.

Development Challenge: The app does two interesting things underneath the hood… First, given an arbitrary number of thumbnails with different aspect ratios, it finds the best sized rectangle that completely fits all the photos. This allows me to recursively stitch groups together and always output a rectangular thumbnail for the group. Second, the pinch/zoom UI uses these nested thumbnails directly without slicing/dicing to fixed sized tiles.

I’m building a polyglot web framework in 15 languages, with C# and Lean4 as the reference implementations. Structural and behavioral audits using deterministic tools check that every port stays consistent with the reference. It’s about 1.8M lines now. I have not reviewed the code/neither have i verified the behavior tests except at the time of giving requirement and never seen some of the language code at all.

The question is how far can we produce “working code → correct code [Possible] → good code [Unknown]” with deterministic audits correcting structure, ai mistakes and behavior validation.

So far the quality looks acceptable with lots of correction of AI output done without looking, but it isn’t fully verified.

Line counts per language, with changes since August: https://claude.ai/artifact/5f1m1pTM7tZ4boQzwsoAG7

A bit like iodine in the basic idea, but the execution and network topologies you build with it are different. It’s more of a building block; you get your DNS channels represented as UDP endpoints, and take it from there, ie you can run Wireguard over it, or SSH or a SOCKS5 proxy (using quicmux, so over QUIC), or run Mosh straight over DNS if you’re crafty.

It has an Android app too! I tried to submit it to F-Droid but they’re so swamped in spammy or low-quality apps that they’re not taking any brand new apps 🙁
A sad state of affairs, that.

It’s been a fun project to work on since it’s been a pain point for myself on many projects, so I’m mostly just trying to solve my own set of problems and hoping other people find it useful too.

[1] https://sendery.co

I was trying to solve the problem I had with time-blocking, where your day ends up derailed and you give up on it because it takes too long to replan. I have solved with the idea of a cascading calendar. If I move a task down or change its duration it pushes other tasks later in the day.

Since then its kinda grown into my full productivity system for logging my thoughts and planning and documenting my life

https://emberflow.space

You can demo here for free
https://demo.emberflow.space/?ref=hn

Send your beacon to a group, and everyone gets a gentle ping. The first person who answers gets connected for a 1-1 call, and for everyone else the signal drops silently. It does not log any missed calls so there’s neither pressure to answer nor pressure to return calls.

Overall it works really well! It’s best if you’re able to join with 4+ friends/family you’d like to chat with more. I have dozens of connections in the app now and it feels like absolute magic to me. I tap the button to send my beacon to everyone and get a random friend on the line.

https://trybeacon.chat/

I’m looking for ways to fund printing and distribute the book. If anyone has done something similar, I’d love to learn from your experience!

Not really sure what to call it, Linux kernel ish implemented in JS so you can run it in the browser. Each program runs in WASM. Everything bootstrapped from a C/Cpp compiler compiled from source with a new target. Also kinda turned into Docker for WASM.

Recommended for people that feel a strong urge to run a browser inside a browser.

https://slopshare.dev/v0.1.5/wine/

Also quite useful to run coding agents sandboxed inside the browser, with HTTP policies and “backend managed skills/extensions”. Compiles Codex from source (has a rust compiler), runs pi agent and CC (the old node one) on a custom javascript runtime on top of quickjs compiled inside the environment.

Everything is static JS (or the robots are lying to me)

The main feature is, that I can use different subscriptions/API keys (Claude and Codex – v0.1.4) and trackers (GitHub, Linear and Huly – v0.1.4) to make Even Keel start an agent for every single issue, task by task, one at a time per folder. There is also a parallel feature, so I can run more than 1 project at a time.

Once upon a time, when codex agent was integrated into the app, I wrote a ticket to make codex his own hook. It reused a hook that blocked its own git merge, if tests did not pass. I started calling it “A new agent writes its own cage”… Right after, it turned out it doesn’t listen to the hook and it fixed it

Version 0.1.4 is already shipped, but v0.2 is coming soon with more supported trackers, agents and new features.

https://github.com/NamerekT/even-keel

My first idea is to require the user to have more than one disk for the system needs and the system should know all of the rest data devices user owns. My second idea is to treat different files as having different priority which impose multiple copies. My third idea is to make the software accessible, and the last idea is to make encrypting of all the devices easy and with no ties to any commertial entities. I would like to have a discussion about how to not lose anything digital.

It started with building pi in the cloud – with pure cloud flare workers. I have it working now, and can spin up – the wrangler agent can fully run it as long as you pass it an inference key, including a file view, a chatgpt like experience, and ability to build and host custom apps. Can use alarms to wake up to do plain language tasks, etc.

Trying to figure out how to package this up, and where this would even be useful for other apps.

Also revived old project – https://aminosplore.metacursion.com – the idea was to compare what essential amino acids each food contains using spider web chart. It’s been dead for a while due to USDA API changes so I revived, added macros and enabled to build foods into actual recipes.

Finally have been improving elsrc.com – an easy and scalable way to use ai image generators. If you need hundreds of images you can just request them by url. Supports versioning, batching, regional and national styling based on viewers IP and few other neat features!

I like sports! I like data! Combine!

This lets you see what the games on today are most similar to in the history of the sport. Click into one and see.

Also, the Sports Zodiac.

Like farmers of the olden years and the stars, we kinda set our clocks by sports these days. But what does that look like?

‘Play the Years’ to see a good timeline of how the years go by.

The war years, the lockouts, and the pandemic are just really easy to see in the data and quite stunning really

It’s a one-to-many phone call that only one person can answer. Send a beacon to a group, and everyone gets pinged at the same time. The first person who answers gets connected for a 1-1 call, and for everyone else the signal drops silently. It does not log any missed calls so there’s neither pressure to answer nor pressure to return calls.

Overall it works really well!
It works best if you’re able to join with at 4+ friends/family you’d like to chat with more. I have dozens of connections in the app now and it feels like magic to me. I press the button and get a random friend!

https://trybeacon.chat/

Not quite ready to open up sign-ups, but you can get an idea of the site here: https://linkedl.ist/@kale

The idea is that the source code is annotated with special rules which configure how parts of the code (also configs and docs) depend on each other. This can be done either directly in the source code comments or in a config file blockwatch.toml

This tool is very useful for large codebases that e.g. share constants across programming languages and configs, have docs that should strictly reflect the current state of the code, etc

It uses tree-sitter to parse the source code, 35+ languages are supported.

The project is actively developed, your feedback is welcomed! Thanks!

I always got annoyed by change this h1 to h2, add tracking to share button, why can’t the customer play the video, the styles don’t match figma.

If you are engineer who also gets distracted I would love to hear your opinion and feedback. It is a bit hard to put it all together as every department has his own needs and opinion about the website.

My email
[email protected]

Thesoapbox.email – a social experiment email lottery to see what people do when suddenly given enormous reach. Every day a new subscriber is drawn to email the whole list. It’s hit 10,000 views in a couple of weeks which is my most viral project so far.

The second – a personal AI learning platform built on recursive self improvement and tailored content to push my boundaries. I’m a lifelong learner and this unifies everything for me.
(Currently not public)

Probably the most interesting thing about it at the moment is the editor. The world, and most things in it, are represented as collections of SDFs. More accurately, they’re density fields, but, potato-tomato. One neat thing about representing the world as SDFs is they’ve been thoroughly researched and documented by a guy named Inigo Quilez, and they have a lot of nice mathematical properties. For example, you can do a smooth union of arbitrary SDFs to get nice rounded contours where shapes join.

The world generator and editor operate almost entirely on the GPU. The terrain and editor pipeline is a three stage process. The first stage is user-configurable; users write an arbitrary ‘shaping’ shader in GLSL. The second stage is a fused stage; it does a convolution on the output of the first stage to compute a normal, runs a second user-configurable ‘decoration’ function, and finally applies edits. Edits are collections of SDFs that are ‘compiled’ from a graph structure on the CPU into a bytecode, and interpreted in the shader. The last stage runs another convolution to compute the final normal, then packs an occupancy bit, color, and normal down into a 32-bit representation, suitable for transfer back to the CPU. I expect I will expand this to include additional user-level bits for encoding biome type and GPU-driven spawning.

The entire shader pipeline is one fused ‘ubershader’ .. everything is bound at startup and the shader is dispatched three times, incrementing a ‘Stage’ uniform on each dispatch. This strategy conceptually makes the driver overhead nearly zero, and the profile agrees.

The final step in the process is giving the CPU a chance to spawn additional entities and structures after generation. This is not completely fleshed out, but the bones are there. The idea is that the results of the GPU work are passed back to the CPU, which can run arbitrary callbacks to spawn additional edits and entities. Once spawning is complete, the result is meshed using a fast binary meshing algorithm and uploaded to the GPU. I keep 16 bits of data per voxel from the GPU work, 1 bit of occupancy, and 15 bits of normal for collision response, which works out to half a megabyte per chunk. At the moment I only keep chunks which contain a piece of the world surface, and discard the rest. Surface chunks are dense, and may be compressed in the future, but keeping this amount of data scales to world sizes greater than 1B voxels cubed, which seems good enough for now.

In terms of raw performance, GPUs are ridiculous. My 3080ti mobile gets somewhere on the order of 500B-1T perlin samples per second with a naive perlin implementation. Compared to FastNoise2, that’s about 1000x more, which sounds wrong since my GPU only has 35x more capacity, but, that’s what my initial profiling said. That number is the marketing number; the real throughput is significantly less due to multi-stage nature of the system, but, there’s a lot of headroom for improvement. For example, dropping the backing textures from 32bit to 16bit roughly quadruples performance. Since we only really care about the surface where values are near zero, I believe using 8 or 16 bit is a viable option, though this claim will require a fair amount of study to validate.

All in all, I’m pleased with how this is all working out. My original goal was to write a highly flexible system giving users both easy-to-use tools and granular control over the final output. I think I’ve done a fairly good job at that, and the fact it’s also super fast is the cherry on top.

I’ll do some shameless self-promotion and leave some links here for anyone interested in looking at the engine, language code, or some pretty pictures.

https://github.com/scallyw4g/bonsai

https://github.com/scallyw4g/poof

I just started using AI a few months ago. My smoke-test was “can it write a simple memory allocator”. Until recently, every time I tried to get an AI to write an arena or simple buddy-style heap allocator, they just vomited all over themselves. To my surprise, the last time I tried, the AI absolutely crushed it; it unearthed tricks I didn’t even know about in one shot. Since then, I’ve been using AIs to do the boring, rote work that effectively just boils down to me typing in something that’s in my head. For that, they’re great. I typically sketch out the thing I want it to make, then tell it to fill in the blanks. Sometimes they still go off the rails, but all in all it’s a useful tool.

Where I’ve found they still struggle is making any architectural decisions, or where performance matters.. even a little bit. They often make super braindead decisions when it comes to performance for no discernable reason. They’ll course correct when you tell them to, but I’ve had to keep a close eye on the output and reign it in frequently. Asking an AI to design a system from the API level hasn’t ever returned a good result for me.. I always do that work.

All in all, I feel like using AI will probably make me a better programmer in the long run, contrary to popular belief. They accelerate the boring stuff I already know how to do, which leaves me with more time to work on the edge of my skill level where I grow as an engineer. Guess we’ll see in 5 years.

Every puzzle is run through a verifier first to make sure it is solvable without any guessing, just by pure logic, so there is always a next step to find, which is what makes it feel so rewarding. There’s a hint system to help and it works really well if I do say so myself . No account needed to play.

From what I’ve been hearing so far, the people who have checked it out are enjoying it and can’t wait for tomorrow’s puzzle, so that’s a good sign.
I’d love to hear how the difficulty feels, and whether the pictures read clearly.

Right now I’m mainly validating whether people would actually want something like this. If there’s enough interest, I’ll run a small closed beta for Android.

Join the waitlist for beta access: https://forms.gle/XWXmK8HUSmAtfms29

So far it’s helpful for messages between my own AI’s (chatgpt and claude etc), and for having my AI trade tech tips with a friend’s AI or talk to my wife’s AI. My AI also got its first message from a strangers AI from france which has also been really interesting. I read all messages first and approve before sending anything, but otherwise they’re just talking about whatever they want.

You write or dictate an entry, and a small model (LFM2.5 1.2B) asks you a question to reflect further. It turns out 1.2B models are decent at asking questions, so I leaned into that. An embedding model finds older entries about the same thing and shows bits of them under the new one.

Most people using it are on budget phones running the models on the CPU, where the app provides good experience.

https://tinta.page

It’s a traditional systems language in the sense that you have fine control over how resources are used, but it’s abstract in the sense that you have to come to an agreement with the compiler about your intent around the resources, rather than directly declaring the machinery.

It’s a distributed language in the sense that there is a higher level structural abstraction in the language that situates computations of the program within a recursive graph structure. Part of that structure incorporates message broker semantics. This gives the compiler a unified view of programs across arbitrary process boundaries. The structural abstractions also enable an effects+formal verification syntax within the language, which allows programmers to codify architectural decisions that are then checked by the compiler.

The compiler itself is infrastructure aware, and the highest layer of functionality it handles is configuring the environment into which applications deploy. The single language handles everything from individual memory allocations to distributed fleet deployments.

The language is close to v1, and I’m currently building a fully distributed inference-as-a-service application with it. Arbitrary hardware/supply matched against arbitrary callers/demand in real time.

https://github.com/hale-lang/hale
https://github.com/hale-lang/voice

It has if nothing else been very useful for me (it has correctly deduced that I would get something out of borrowing Grief is the Thing With Feathers, the Dispossessed, and Cosmicomics, none of which I would have thought of reading). Plus it has been a fun opportunity to play around with LLMs as an interface and a research and reverse engineering tool; as well as Jev for non-user facing quality work like banning crap openrouter providers based on their output before putting it in front of a user.

Most recently I’ve been dropping off flyers for it at a few local libraries in my area.

* files in organised trees/graphs generated using LSPs and symbol references instead of linear file list
* keyboard shortcuts for everything from navigation, pan, zoom, comment, note, submit…
* mostly github compatible with native features
* LSP powered symbol resolution for inspecting definitions and references
* LLM powered reviews supported
* Inline LLM question answering

https://porchlit.app/

I built the original for myself because I wanted to listen to acoup and other history blogs while sleeping. And in the spirit of getting better at finishing projects decided make it public even tho it’s nothing really unique or special.

Still lots to polish especially in the text/copy and ui but the core features should be working.

Looking to pilot for free with small qualified teams (early-stage startups with real/immediate need).

[email protected]

https://github.com/InditexTech/kumoss

Basically allow developers to request any infrastructure need in a web portal and automatically that request is fulfilled following the organization standards the platform team defined.

Any feedback or comment is more than welcomed!

Any feedbac

Added an audio player this past month for all fellow file hoarders out there.

Also, you can now choose if you want Gusco to live in your terminal or run as a native-yet-texty app.

Was pleasantly surprised how well turning a Bubble Tea TUI app into a GUI-ish bundle works with Gio UI.

switching from iOS, I wasn’t happy with the existing podcast apps, so I built this mostly for myself. I’ve been using it for the last six months and finally pushed a public beta.

My day to day is BE so I used the project to learn Kotlin and Jetpack Compose. Everything is strictly native using Room and Media3/ExoPlayer. I wanted a nice looking (subjective), privacy-focused app without any tracking or ads.

I’m considering open sourcing it soon.

https://play.google.com/store/apps/details?id=com.enyodigita…

Features:

– No paywalls, bandwidth limiting, or crippled behavior. No login required.

– Single go binary, deployed via Docker.

– Reaches your home server from anywhere with no port forwarding, no VPN and no paywall, even behind carrier-grade NAT. No Tailscale required.

– Cast to another device. You can use any logged in device as a playback screen.

– Watch together, with voice support: Play synced video with friends, and also chat voice. You can also mix this with casting to another device.

– Dialogue boost and loudness levelling for every film.

– Real adaptive quality, tuned for a home’s upload.

– Hardware transcoding, full quality in every supported browser.

– A library that explains itself: what the scanner saw, why each title matched, guesses marked for you to check, and a disk that’s gone missing shown as missing instead of its titles silently vanishing.

– Your data stays yours: The database is a rebuildable index, metadata corrections can be written back as NFO files that Kodi and Jellyfin read, and an automatic backup keeps what can’t be re-derived (watch state, preferences, shares).

Security is a primary concern:

With the ever increasing pace of hacks and CVEs and AI-assisted intrusion, you simply can’t be too careful anymore.

– The core (which talks to the network, handles the API, users and the database) never opens a media file or runs FFmpeg.

– A separate media node does every file read and every transcode. It has no network access and talks to the core only over Unix sockets.

– FFmpeg runs under Landlock and seccomp with no path to the file and no socket. All it can do is read and write streams.

– Small dependency tree on an allowlist, pure Go with no cgo, secrets sealed at rest and never logged.

– The library can be mounted read-only, so even a full compromise can’t encrypt or delete your media.

– Cryptographically signed chain for servers and releases.

https://orpheum-app.com/

I didn’t want to switch/refresh bunch of tabs. That’s why I made this one.

not screenshots. so you can still interact with the pieces like in normal web browsers.

But apart from that, I just updated my website’s theme to something I wanted to do for quite a while now – a fantasy desktop!
If you’d like to check it out: https://0xff.nu

I’m also trying to just learn new things with the time I was refunded by being unemployed.

Client posts request and masters respond with their offers.

What you think about that guys?

Good news though, these days Claude will just do it for me!

I’ve been working on setting up a home media server, using headless Debian on a pi – I’ve got it set up to stream music and videos, hold all my ROMs, I’ve got it automatically standardizing file names and handling tagging and subtitles – all attached to a big 6-drive enclosure that I just stuffed all my random old HDDs into.

Even though I haven’t written more than a dozen lines of code or commands for the whole thing, I am pretty fuckin pleased that now I can just wave a magic wand and say “I want all my video game soundtracks filed under the game name rather than the artist” and Claude uh finds a way to grant my wish. I spend about an hour each night tweaking it and it’s so easy to customize to be exactly what I need.

The terrain and editor pipeline is a three stage process. The first stage is user-configurable; users write an arbitrary ‘shaping’ shader in GLSL. The second stage is a fused stage; it does a convolution on the output of the first stage to compute a normal, runs a second user-configurable ‘decoration’ function, and finally applies edits. Edits are collections of SDFs that are ‘compiled’ from a graph structure on the CPU into a bytecode, and interpreted in the shader. The last stage runs another convolution to compute the final normal, then packs an occupancy bit, color, and normal down into a 32-bit representation, suitable for transfer back to the CPU. I expect I will expand this to include additional user-level bits for encoding biome type and GPU-driven spawning.

The entire shader pipeline is one fused ‘ubershader’ .. everything is bound at startup and the shader is dispatched three times, incrementing a ‘Stage’ uniform on each dispatch. This strategy conceptually makes the driver overhead nearly zero, and the profile agrees.

The final step in the process is giving the CPU a chance to spawn additional entities and structures after generation. This is not completely fleshed out, but the bones are there. The idea is that the results of the GPU work are passed back to the CPU, which can run arbitrary callbacks to spawn additional edits and entities. Once spawning is complete, the result is meshed using a fast binary meshing algorithm and uploaded to the GPU. I keep 16 bits of data per voxel from the GPU work, 1 bit of occupancy, and 15 bits of normal for collision response, which works out to half a megabyte per chunk. At the moment I only keep chunks which contain a piece of the world surface, and discard the rest. Surface chunks are dense, and may be compressed in the future, but keeping this amount of data scales to world sizes greater than 1B voxels cubed, which seems good enough for now.

In terms of raw performance, GPUs are ridiculous. My 3080ti mobile gets somewhere on the order of 500B-1T perlin samples per second with a naive perlin implementation. Compared to FastNoise2, that’s about 1000x more, which sounds wrong since my GPU only has 35x more capacity, but, that’s what my initial profiling said. That number is the marketing number; the real throughput is significantly less due to multi-stage nature of the system, but, there’s a lot of headroom for improvement. For example, dropping the backing textures from 32bit to 16bit roughly quadruples performance. Since we only really care about the surface where values are near zero, I believe using 8 or 16 bit is a viable option, though this claim will require a fair amount of study to validate.

All in all, I’m pleased with how this is all working out. My original goal was to write a highly flexible system giving users both easy-to-use tools and granular control over the final output. I think I’ve done a fairly good job at that, and the fact it’s also super fast is the cherry on top.

Most of the essential features are implemented so far, but some (mandatory) features are lacking (xattrs support). My goal is to get to a full ext4 implementation that also supports ext2 and ext3 read/write.

The initial motivation was to have a pet project with a use-case for Rust, as I wanted to improve my Rust coding skills, after I did some work on a game server implementation in Rust earlier [1].
My goal is to have an implementation where I have digested every line mentally, which is something that pretty much excludes slop-like use of AI for large scale code generation. And of course I want to really trust the code that touches my files via raw hard disk access.
Hence, I use AI mainly for unit tests and (scoped) code rewriting when my code gets too verbose and cumbersome.

In the long run I’d want to add fuzzing to the implementation, so if anyone has experience on this, I’d be interested in getting some pointers.

[1] https://github.com/MordorWide/EANation

https://apps.apple.com/app/id1464477788

…according to my own benchmarks (yeah, I know how that sounds).

Next, I’m planning to submit it to independent third party benchmarks, hoping to find out whether my results are accurate… or not 🙂

I’ve also just finished a CSS framework: https://iriscss.com/

Now I’m working on a new backend programming language that runs on the Erlang BEAM, along with a few web applications built using this tech stack.

https://ur.dev/en/

Take a look at FFmpeg as an example. It’s a complex tool that can do most things audio/video. A power user can do magical things, but they still provide simple commands for the most basic use-cases like conversion or trimming.

https://www.clipcat.com/blog/how-to-use-ffmpeg-a-beginners-g…

1. Provide sensible defaults
2. Study user journeys and write simple manuals for them.
3. Ask friends or internet communities for feedback.

Don’t get discouraged, you can do it!

Accept online card payments from just 0.79% (UK) and earn 0.89% on all card spend [1], or get paid out to your bank.

I’m building tuppence to be available in the US, and 20 EU countries.

I’m getting a Point of Sale (POS) manufactured in the UK [2] for those who want to accept payments in person with card readers.

My goal is to help people sell their goods and make a living without paying over the odds for the privilege.

I charge a competitive fee for payment processing, give money back on card spend (with no cashback caps/limits) and do not charge saas fees or lock people into contracts.

Tuppences currently allows people to sell online with a store builder, expense management, payment links, direct debits & bookings – essentially Tuppence is a ‘business’ layer on top of what you get from the likes of Stripe, Adyen and Checkout.com. There’s also have a ‘connect’ platform, so you can roll this out to your marketplace business.

Next on my roadmap is ticketing and ‘treasury’. Treasury i’m personally excited about as you’ll be able to earn 4% yield on your earnings, FDIC Insurance (FSCS in the UK), multi-currency banking in fiat balances such as USD, EUR, and GBP, or stablecoin balances like OUSD and USDC, and have bank account numbers to send or receive funds.

—

It’s brand new, i’m still testing payment -> payout flows. These take a little time to verify on live payment rails.

Happy to give some fee-free payment processing for those who reach out and want to be early adopters, I can be reached at [email protected], or comment on thread.

—

Tech Stack TLDR:

* TypeScript monorepo covering the API, dashboard, docs, mobile app and SDKs.
* The API runs on Ts.ED over Express with TypeORM and Postgres.
* Background jobs use pg-boss, so the queue lives in Postgres and there’s no Redis or separate broker.
* The dashboard, till and storefront are React + Vite + Tailwind, the docs and help centre are Astro, and the mobile app is React Native/Expo. We ship SDKs for Node, Python, iOS, Android, React Native and WordPress, plus an MCP server and agent tools.
* Everything runs on Google Cloud Run and Cloud SQL.

References:

[1] Card issuing: https://tuppence.ai/cards
[2] Point of sale: https://tuppence.ai/pos/ridge/