Ask HN: What Are You Working On? (December 2025)

An PWA primarily for my wife and my daughter. They can order their hot chocolate and their coffee as if they were going to grab something at a fancy café downtown, but instead it's at home and I'm the barista. It is quite nice to have for when my wife comes back from work and want something specific, or when we are waiting for the visit of a few friend, they can order exactly the available beverages and everything is ready when they're here.

It was also a good playground for me to implement Web Push notifications (to never miss new orders).

It's a basic Nuxt 3 app with Appwrite as the backend with rough edges, but much enough for our household use !

If you want to spam my phone with notifications, please visit my café : https://mytinycafe.com/alix

Right now I have a build that loads in the browser, but I really want to have "multithreading" which means workers in the web. One can use asyncify with emscripten to translate blocking C++ to WASM, but that transition is not perfect, right now I'm debugging a bug where there's a race condition that halts all execution and the main thread runs in an infinite loop waiting for the workers to stand up. I guess I'll have a few of those ahead.

The main goal is to 1. just have fun 2. use yjs as a collab backend so multiple people can edit the same PCB. This will probably work with pcbnew, KiCad's layout editor, since it has a plugin system and AFAIK I can do the sync layer there. For the rest ( schematic, component editor etc. ) I'll have to figure out something.. KiCad does not sync automatically if you modify a file, I'll have to do some lifting there.

Anyway, it's a lot of fun, I really want this thing to exist, I'm hoping that I won't run into a "wellll, this is just not going to work" kind of issue in the end.

Completely free, no ads, no in-app purchases and no accounts / network required offline voice transcription.

I have also built the macOS/Windows/Linux versions which I'll also make free to download and available on my site soon (https://blazingbanana.com/).

iOS version is built and works (extremely well), just waiting for the Apple Developer signup process to complete.

Big shout out to https://github.com/mybigday/whisper.rn and https://huggingface.co/ggerganov/whisper.cpp/tree/main for making this even possible.

Any suggestions are welcome.

I made a daily word puzzle called Tiled Words.

https://tiledwords.com

Currently about 2,000 people play every day and I’ve released 59 puzzles!

One feature I’m excited about is crowdsourcing puzzles. Today’s puzzle is a “community puzzle” made entirely from clues that players submitted! I plan to do this every week or two.

I wrote about launching and the first month of puzzles if you want to learn more!

https://paulmakeswebsites.com/writing/a-month-of-tiled-words...

Focused on all the interesting and exciting happenings in tech here, from AI to defence to deeptech, and posting the most interesting job openings too. Did you know Europe had two space launch startups? I didn't until I started this project!

Feedback very welcome :)

It started out as something marginally more useful than vendoring your dependencies as submodules + baking in the knowledge of how to build a bunch of common projects.

I realized, though, that there was somehow a huge gap in the insane world of C build tools. There's nothing that:

- Lets you pin really precisely and builds everything from source (i.e. no binary repository)

- Does not depend on either a scripting language or a completely insane DSL (Conan uses Python, CMake is an eldritch horror, ditto Make, lots of other tools of course but none of them quite hit the mark)

- Has a good balance of "builds are data" and "builds are code".

Anyway, it's going great. There are, of course, a ton of problems to solve. Chief among them is the obvious caveat that C is not a monoculture like Rust. There will be zero upstream libraries that use this tool natively. But I don't think it matters. I think I can build something which is as much better to the existing tools as, say, UV was to existing Python tools, even with that disadvantage.

- Currently in free Early Access with 18 competitive mini-games.

- Players use their mobile phones as controllers (you can use game pads as well!)

- Everything is completely web-based, no downloads or installs are necessary to play

- All games support up to 8 players at a time and are action based, with quick ~one minute rounds to keep a good pace. This means there are no language based trivia or asynchronous games!

- In the future we plan to open up the platform for 3rd party developers (and Gamejams!) as well. We take care of the network connectivity, controllers etc.. 3rd party devs can focus on developing cool multiplayer mini-games without spending an eternity with networking code and building the infrastructure.

Interested to hear if this resonates with Hacker News readers!

Here is a work in progress build:

https://muffinman-io.itch.io/space-deck-x

It is a combination of a shoot-em-up and deck building. You fly and shoot until you get to the boss, when you get your deck out to fight them.

That genre combination is definitely too ambitious, but I think it is fun to play and I’m enjoying making it.

I have a bunch of ideas how to combine the two parts better. But over the years, I’ve learned to control scope creep and actually ship pet projects.

Right now I’m in a middle of changing how enemy waves are spawned. After that I want to make a short tutorial and add two more bosses as well as more enemies.

If you end up playing it, please share your feedback I’ll be glad to hear it.

The game is made using Kaplay, a game dec library which brings me joy to use. I can best describe it as my friend described Pico-8: “easy things are easy”. But compared to Pico-8, Kaplay doesn’t have virtual console limitations and comes with a big library of components. Try it out, the community is small, but the library itself is really fun and easy to use.

EDIT: For context, this is about two weeks of work, in the evenings when my kid is asleep.

The problem for me was trying to read and understand the implementation of a swiss map implementation. The SIMD instructions were challenging to understand and the documentation felt difficult to read. I thought that if I had an interactive tool where I could set the inputs to a SIMD instruction and then read the outputs, understanding the instructions would be much easier.

This turned out to be true.

Building this tool for all AVX/AVX2 instructions turned out to be a larger task than I had expected. Naively I just went off a Wikipedia page on AXV and assumed it had listed all the instructions (this was a bad assumption).

I am nearly there. Looking forward to completing this project so I can actually use it to do some fun stuff processing text and maybe even get back to that swiss map implementation.

https://github.com/fmstephe/simd_explorer

(This is also my first attempt at a TUI app)

https://ookigame.com/

All the games were either developed with libGDX or threejs. I have no plan to monetize yet and still work on building traffic and improving SEO. Surprisingly, I got approved for google adsense already, which I submitted just for experimenting.

I learned that ships have a "max load" line (or Plimsoll Line) https://en.wikipedia.org/wiki/Load_line_(watercraft) to prevent overloading them with cargos, but my todo list didn't. So I built an app to surface my emotional load and put mental health above raw productivity.

I am experimenting with the concept of giving each item in the iOS Reminders app an impact multiplier between -1.0 and +1.0 to assign them "weights". The net weight of the todo items should indicate my overall mood or emotional burden. If it doesn't maybe I have yet thought about what's making me feel good or bringing me down. The net weight is visually represented by the "water line" that rises the more into the negative the net weight becomes. I'm thinking of adding features to nudge me into addressing the rising water line.

And since I want to lower my own stress and anxiety using this app, there is no signup or subscription. No data collection other than the bare minimum to make the "tip jar" working through the App Store IAP, so no PII collection.

Do you think you'd find this approach to be helpful for managing your own anxiety level?

(Edited to add a bit more clarification)

USCIS forms still use XFA PDFs, which don’t let you edit in most browsers. Even with Adobe, fields break, and getting the signature is hard.

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

https://fillvisa.com/demo/

What Fillvisa does:

- Fill USCIS forms directly in your browser - no Adobe needed

- 100% free

- No login/account required

- Autosave as you type

- Local-only storage (your data never leaves the browser)

- Clean, mobile-friendly UI

- Generates the official USCIS PDF, ready to submit

- Built-in signature pad

I just wanted a fast, modern, free way to complete the actual USCIS form itself without the PDF headaches. This is a beta version

Happy to get any feedback :)

The first days were so hard but now I’m getting used to it. I documented it here: https://ramezanpour.net/post/2025/12/11/dopamine-detox-is-ha...

Currently spending time establishing relationships with historical societies, as I really need them to contribute points of interest, and stories. Many of these societies are run on a voluntary basis by 70+ year olds, so it's a long process. Getting some good responses eventually though, so it might actually go somewhere, just a lot slower than I want.

Also still doing https://wheretodrink.beer, but haven't added anything of note since playing on this other project.

And react2shell was a blast

I am running it in my city for a library of things. We hope to help people abstain from buying things they only need once a year.

It includes a reservation system, and an dashboard to manage those reservations in the shop. Currently I'm expanding it with a proper product management interface.

My team is also about to ship Atmos [1], a lamp for the bedside that automatically shifts from higher-blue light during the daytime to low blue light at night.

[0] https://restfullighting.com/bbv2

[1] https://restfullighting.com/atmos

https://mydragonskin.com/products/stingray-treatment-kit

You can find the CC0 postcard app here: https://sweetpost.art/ but if you want to go the extra step you can install the Chrome extension and see what comes up: https://chromewebstore.google.com/detail/new-tab-new-art/old...

edit to add Firefox addon: https://addons.mozilla.org/en-US/firefox/addon/new-tab-new-a...

If you want to send a postcard you can use the promo: 1BUCK to send a postcard for a dollar to whoever in US. Any feedback or questions are welcome.

Working on a new newsletter to encourage people get off social media by helping them discover all sorts of random interesting sites that exist out on the open web.

The idea is simple, but I think it could be really cool: an autonomous agent that actually manages an entire radio station. It creates its own shows, play copyright-free tracks, shares the daily program schedule on social media and the website, and later I want to add guest appearances too and live 7/24.

With LLMs, generating ideas and snippets is cheap; what’s hard is keeping track of fragments with their “why I cared” context over months. Most tools (Notion/Obsidian/etc.) assume you will do the work (folder/tag/linking) structure will maintain it forever. I don’t.

In LACE we: – capture fragments from the web via a browser extension – auto-cluster them into evolving “threads” / projects with summaries & reading lists – maintain a graph of connections across threads (“topology of attention”) – let you turn a cluster of fragments into an essay draft when you’re ready to share.

Stack is a fairly standard web app + LLM pipeline. Used neo4j's llm-graph-builder as a starting point.

The interesting bit is self-organising graph. treating fragments/questions/lines of inquiry as first-class objects and letting the system reorganise around them over time instead of fixed folders.

It’s in a small test phase right now. If you’re a researcher/writer/engineer/founder who constantly loses good ideas in your notes and want to try something opinionated in this space, I’d love feedback.

background write-up: https://open.substack.com/pub/ozthinks/p/from-fragments-to-i...

I’ve written a PoC already (mind the crappy and incomplete UI), mostly to test the wild custom UI idea, and it’s working so far! https://i.redd.it/ocx9m5av6d6g1.jpeg

https://github.com/Fingel/gelly

Available on Flathub: https://flathub.org/en/apps/io.m51.Gelly

Currently trying to better contextualize the visible subregion of the matrix in relation to the full dataset (beyond what the current minimap does).

https://cybernetic.dev/matrix

https://aibodh.com/posts/bevy-rust-game-development-chapter-...

https://aibodh.com/posts/bevy-rust-game-development-chapter-...

https://aibodh.com/posts/bevy-rust-game-development-chapter-...

I've always loved electronics since I was a kid (still trying to learn). As I explore and learn I've begun to make these small "breadboard helpers" [1]. (Just one on Resistor Transistor Logic (RTL) right now.)

An obsession over a project in a 1970's hobbyist electronics magazine sent me down the rabbit hole that is (was) analog computing. So I have been bread-boarding and prototyping small analog computer modules.

I'm in the PCB-layout stage for the modules and hope to have them ready early next year.

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

https://apps.apple.com/de/app/camera2url/id6756015636

Camera2URL is, as far as I know, the only iOS and macOS application that let‘s you send the picture taken with the camera directly to any HTTP endpoint the moment you press the trigger.

For example, this makes it possible to trigger an n8n workflow the instant you take a photo:

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

It started as something I wanted to build for myself. I have a Bosch dishwasher that lacks any glanceable indication of how far along it is. Bosch provides an app, but checking the progress takes too long to be useful.

I figured live activities was a good fit, and then realized that I am not alone in wanting something like this. So, I am trying to make it into something usable for all the home automation tinkerers.

https://getaivi.app

Very early days still. Whilst I created a fork of toon for Kicad (called TOKN (https://www.mikeayles.com/#tokn)), with the intention of using a reduced token format to generate schematics using LLM's, I could get the models to follow the syntax correctly, but they didn't have the knowledge. So I was then going to create a whole RAG system, but got distracted by this current project.

There are people out there doing AI schematic generation, like flux.ai (which is incredible (and incredibly well funded)), but 90% of products, especially at proof of concept stage, are basically a microcontroller, some power, probably usb, and some IO, bluetooth/wifi if you're lucky. So we can use a library of pre-validated subcircuits and slots them together on a grid. Routing's deterministic, so if it compiles, it works. (sorry, deeppcb & Quilter!)

The enclosure side is more fun: once the PCB's done you've got real dimensions to work with (board size, mounting holes, where the connectors poke out), so I use an image model to generate some concept art, then feed that to an openscad generating model as visual inspiration alongside the hard constraints.

Basically trying to get a full hardware product pipeline done automatically.

https://github.com/btrettel/blastersim

The core simulator part works, but I don't yet have a user interface or documentation. Probably just going to be text input files to start, maybe a GUI later. Recently, I'm mostly working on testing.

The simulator is object-oriented and basically allows one to build up a blaster from separate control volumes and connections between control volumes. This is useful as it allows the same core simulator framework to handle different blaster configurations and even variants of them. For example, someone asked me to make the spring piston able to pull a vacuum on its back side due to not having sufficient flow. That's easy here as I just need to add another control volume and the appropriate connection onto the basic springer configuration.

Lineage-aware. Versioned. Trustworthy Data - for Engineers and AI.

Your engineers waste up to 40% of their time monitoring, investigating and fixing data. Even then you don’t trust the accuracy, source, or freshness of metrics on your dashboard. You wish AI can answer your data questions but it cannot show you proof, or where it came from. AI helps software engineers to move fast and break things, because they can always rollback, with git. But you cannot do that for data. Bad data entering the system, spreads across the company before spotting, and takes weeks to clean up.

DV changes this, giving you lineage-aware, versioned data. It records data-lineage when data is captured, transformed, and committed, at commit/snapshot level. So when things break, DV knows what other data is impacted downstream, and it can rollback the whole chain to the previous state, instantly - no data copy/restore needed. It can also backfill the data across the chain automatically.

With DV, both your team and your AI agents can finally see: - where data came from - how it was transformed - how to revert safely with a single click

Your engineers can move fast on data, without breaking trust. Your analysts can build pipelines by simply describing business questions to AI.

DV is Git for data, so you can focus on your business, putting analytics on auto pilot.

-- Please contact me if you are interested in preview program.

https://github.com/MarkusSintonen/pyreqwest

Trying to build a small-scale ISP/hosting provider domiciled in Canada. We really want to be able to rent real rack space to enthusiasts who would like to benefit from having stuff in the datacenter but don't want to take on the opportunity cost to get started. It came out of my own desire to have a machine in a DC rack.

This week we've been writing a bunch of "reviews" of self-hostable software since a lot of our friends are curious about this space but don't have a good understanding of how to get started. https://blog.colocataires.dev.

I've tried to make it look and feel at home in iOS and I like to think of it as a Notes app for the gym—it does very few things and does them well.

It's completely free with no ads because I'm not a fan of how other workout apps charge you for a basic workout experience.

I've just finished up the Import from Strong feature and would love any feedback on it!

https://apps.apple.com/au/app/hypertrophy-gym-workout-log/id...

This will help people set clear expectations for their apartment search.

[0]: https://allaboutberlin.com/tools/rent-map

One amusing thing I've noticed is that every time the AI generates code with a hard coded hexadecimal constant, it's a hallucination. My son suggested feeding all of the chip datasheets into the AI and see if the constants improve.

2. Finally converting my home semi-hobby electronics business (something like a guitar effects pedal) to machine assembled circuit boards.

In the real world finally moved everything to USB-C. Gave all my old cables away. I have two chargers in my home and a handful of C to C cables. Everything connects to everything now.

Home is now downgraded to a dumb home. Lights work on physical toggles. No hubs or sensors anywhere. Heat and AC is with a dumb panel on the wall.

It feels freeing.

All notes are simple markdown file stored locally.

I’ve been using it to benefit my research and make the knowledge to stick better on my head for several years. My base is more than 400 markdown notes now, and I sync them to a private GitHub repository.

https://github.com/odosui/mt

Screenshots in the App Stores, e.g. https://apps.apple.com/us/app/pistepal/id6754510927

Still a little bit rough around the edges but hopefully will be / is in decent enough shape for the start of the ski season (just about happening now..)

Currently figuring out the right balance of free tier & daily trial. Priced at $10/month and therefore significantly undercutting the competition, hopefully this is enough to gain entry into the market. (May need a more generous daily trial though, admittedly 10 minutes is not really enough to actually try it out on the mountain).

Seems ad spend is necessary to get any kind of traction...

Feedback welcome!

I launched this on HN over the summer, but it's millisecond-precise audio synchronization for multiple devices, performed purely in the browser! I'm sitting at around 5K daily active users now. Also, it's open-source!

I don't like JavaScript, and I've been meaning to learn Rust for a while, so I'm compiling the Rust algorithm to WebAssembly to run in the browser natively! It's been a fun trip back into the arcane world of numerical algorithms and linear algebra!

Each of us is reading sixty books over 2026, five a month, where every book is self selected by each member.

It’s small, six people, all brought in by application only.

You can check out our shared bookshelf here! (Heavy inspiration from Stripe Press)

https://bookshelf-bookclub.vercel.app/book/cmj4pfpom001gqsbj...

(swipe left/right on mobile, up/down arrows on pc :))

A Python ORM, inspired by Drizzle and the like. Whenever I come to Python I'm frustrated by the ORM options. They generally lack type-safety on inputs and outputs, or useful type hints.

SQLAlchemy is an institution but I think it's hard to use if it's not your full-time job. I check the docs for every query. I want something simple for the 80-99% of cases, that lets you drop easily into raw SQL for the remaining %.

I'm going to keep hacking at it, would love to from anyone who thinks this is worthwhile (or not). Also: - The interface for update queries is clunky. Should I add codegen? - Should I try to implement a SQL diffing engine (for migrations). Or just vendor sqldef/similar...?

But unlike my day job, this is my project and I get to do what I want. This is my code therapy.

Turns out not that hard.

In about a weekend, I built a UETA and ESIGN compliant tool. And it was free. And it cost me less than $50. Unlimited free e-sign. https://useinkless.com/

Since hacker news last saw it, it’s been translated into English, German, Spanish and Chinese. If, say, a Chinese speaker wanted to learn more English words, then they could go to https://threeemojis.com/zh-CN/play/hex/en-US/today and play the game with English words with Chinese definitions and interface. This is the first cross language daily word game of its kind (as far as I know), so it’s been a lot of fun watching who plays which languages from where.

The next challenge that I’m thinking about is growing the game. The write ups and mentions on blogs add up, the social sharing helps, but I’d really like to break into the short form video realm.

If you read interviews from other word game creators, every successful game has some variation of got popular riding the wordle wave, or one random guy made a random TikTok one time that went super viral, and otherwise every other growth method they have tried since then hasn’t worked that well and they are coasting along.

So, sans another wordle wave, I am working on growing a TikTok following and then working on converting that following into players, a bit of a two step there, but that’s how the game is played these days. https://www.tiktok.com/@three_emojis_hq for the curious. Still experimenting and finding video styles and formats that travel well there. Pingo AI and other language apps have shown how strong TikTok can be for growth, so I think there’s something there. That’s all for this month!

It’s build using ESP32 and a small screen which shows On and Off and the time till meeting is over. I learnt Fusion 360 and designed a small snap fit case and got it 3d printed.

I have a small electron app running in my mac os system tray which connect to esp using BLE and it also checks if Mac Camera is in use (using Apple logs) and then communicate it with the device.

Calling it Door Frame. Had quite fun making it as i learnt 3d design, c++ code using Platform IO and other fun stuff. Even designed a small binary protocol to exchange data over BLE

https://www.lowcostmail.com

Then I wrote a Python program that connects whatever controller my brothers want to use (as long as it's supported by SDL2.0) and forwards that data from their computer, through Parsec, through a USB-UART adapter, to the Pico, then to the Switch. I then have a low latency capture card (Magewell Pro Dual HDMI I got off of ebay for $100) forwarding the video and audio from the Switch to my PC which I share to my brothers via Parsec. The audio was a bit tricky to get right, and ended up having to use a Virtual audio cable and Voicemeeter potato (a software audio mixer) so that both myself and my brothers could hear the audio.

It works surprisingly well and the latency is pretty low. I even got rumble working! (but not motion controls. If anyone wants to attempt it, I will accept PRs). I haven't done any formal benchmarking for performance, but my brothers and I were able to play Smash Ultimate without too much bother about latency.

You could also use the accessory Python library I made to automate switch controller presses (look in the examples directory). Might be useful for TAS speedruns?

The project is here for anyone interested. It's a bit rough and needs some cleanup and maybe a video tutorial on remote setup. But here is the WIP:

https://github.com/jyapayne/switch-pico

Here's the elevator pitch for the framework:

Its built around 3 key ideas I've dealt with inside the agent ecosystem 1. Agents become far more capable when they have access to a CLI and can create or reuse scripts, instead of relying solely on MCP.

2. Multi-agent setups are often overvalued as “expert personas” but they’re incredibly effective for managing context, A2A is the future.

3. Agents are useful for more than just writing code. They should be easy for non-engineers to create and capable of providing value in many domains beyond software development.

If that sounds interesting take a look! https://github.com/brycewcole/capsule-agents

Remixify automates the search while leaving the selection to you. You paste a Spotify playlist URL, and it helps you or provides you a good starting point for digging. It groups the results by the original track so you can quickly preview and save the versions you want to a new playlist.

We don't try to recommend new music or use AI to guess your taste. It just finds the usable versions of the music you already selected.

[1]https://github.com/kwakubiney/remixify

[2]https://remixify.xyz/

My next step is documenting how all of the subsystems work (such as virtual memory, allocators, drivers, etc.), then lay the project to rest. I don't have any grand ambitions for the kernel. The project was just a labor of love, and a way to learn some interesting things! Hopefully some of the documentation can serve as learning material for other people interested in osdev.

Source code and playground here: https://github.com/BarishNamazov/gsql/

Background blog here: https://barish.me/blog/parametric-polymorphism-for-sql/

Feedback is super appreciated!

Video intelligence platform for coaching programs and training companies. The problem: these businesses sit on 200-500+ hours of video content that becomes a "content graveyard" - students can't find what they need, coaches burn out answering the same questions, churn stays high.

We do deep transcript + metadata extraction, then layer RAG search and an AI assistant that can answer questions with timestamped citations back to the exact video moment. Think "ChatGPT for your video library" but with accurate sources instead of hallucinations. Tech: Phoenix/Elixir backend, Next.js portals, two-tier RAG architecture.

Currently serving a few coaching programs in high-touch sales mode. Would love feedback from anyone who's built RAG systems over media content - curious how others handle the signal extraction problem (transcripts are noisy, you need to identify what's actually being taught vs filler).

https://donethat.ai

With lot's of built-in data privacy safeguards https://donethat.ai/data

Also made an overview of similar tools out there https://donethat.ai/compare

Recently broke on Linux with a Wayland security update, working on a fix! Using Electron for cross-platform.

The main problem we're tackling is the quality of automated content for large catalogs. Instead of just spinning existing keywords, we use Vision AI to analyze product images directly. This allows us to generate accurate, accessible alt text and detailed descriptions based on what the product actually looks like.

To avoid the "generic AI" feel, the app also crawls your existing store content to build a custom brand voice profile, ensuring new content matches your established tone.

Key features: • Vision-based generation: Analyzes images for context-aware descriptions and alt text (WCAG 2.1 AA compliant). • Brand Voice Intelligence: Learns from your previous writing style. • Bulk Processing: Handles up to 500 products per batch with real-time tracking.

We have a free tier (20 credits/month) if you want to give it a spin. I'd love to hear your feedback on the "Vision AI" output quality versus standard text-generation tools!

I'm working on Tech Talks Weekly which is a free weekly email with all the recently published Software Engineering podcasts and conference talks in the past 7 days.

Every week I pull all the new talk recordings from hundreds of conferences (Devoxx, KubeCon, PyCon, QCon, LeadDev, JSNation, and many more) and even more podcasts podcasts. I feature the ones I think are must-watch with short summaries written by me, then include a list of everything else uploaded that week.

It started as a personal project to fix my own messy YT subscriptions and RSS feeds and now 7,500+ people read it.

I also publish extra editions from time to time like “The Most Watched Talks of 2024” which made it to the HN front page.

If you watch software engineering conference talks or listen to podcasts, you might find it useful.

I’d love to know what you think!

an AI-native book reader that actually understands what you’re reading.

You highlight text, and the app infers intent and surfaces the right actions inline.

Examples:

Highlight a confusing paragraph → auto-suggests questions like “what does this term mean?” or “how does this relate to earlier chapters?”

Highlight a name → instant character context (no spoilers)

Highlight an argument → concise breakdown, assumptions, counterpoints

It works across EPUBs, PDFs, and papers, and the core rule is: AI should be assistive, never intrusive. No prompts required, no context switching.

Built it because I read a lot of dense material and hated breaking flow.

I built Codeboards, a developer portfolio that updates itself automatically from your GitHub, StackOverflow, LinkedIn, and more. Most dev portfolios are outdated, manual, and painful to maintain. GitHub alone doesn’t show who you are. LinkedIn is noise. Personal websites die after 6 months.

It is opensource, all the computations are done on the client side,

https://github.com/jfromaniello/joseflys

https://joseflys.com

An example of navigation https://joseflys.com/s/UGaIwnEY

If you have played military sim (Milsim) games like Project Reality, Squad or Arma you might appreciate it.

Its quite cool how the game devs have made a lot of tooling to use; they use Typescript to hook into in-game events and functions.

There is a whole community making lots of content too:- https://bfportal.gg/

Currently I am working on an insurgency game mode; where one team has to defend some caches and use guerilla tactics, whilst the other team has a smaller size but the advantage of firepower and vehicles.

Hopefully have it released by Christmas time.

It’s much shorter than my first book, Effective Haskell, and leans more advanced, especially toward the end. Although the format is puzzle focused I’m trying to avoid simple gotcha questions and instead use each puzzle as a launchpad for discussing how to reason about programs, design tradeoffs, and nuances around maintainability.

Seriously, I'm very proud of myself for the little I've accomplished so far. I don't have friends in tech so I don't get to talk about it or bounce ideas off people.

Thanks for letting me get that out!

A place to find and be found for twitter users only right now. As a silly project I am trying to make not a social network, but an extension of another social network. So far its going OK. It also functions as a link-tree like site with profiles: https://meetinghouse.cc/x/simonsarris

Eventually I might open it up more widely, or make a different globe per social media network.

None of the frontier LLMs (Gemini, ChatGPT, Claude) produce usable designs when just prompted with some photos of the pump and a written description of the mount. I'm now building a simulator in Mujoco that the LLMs can use to test and iterate on their designs to see if they can do better in this setting.

I'm hoping to make an interesting blog post of it and maybe end up with a usable wall mount design.

It’s been incredibly rewarding to see people’s changing opinions of their local government

I love online Unicode tools, serious ones and silly ones, and I use them often for fun or for development. What I see online is that few technical people have a good understanding of Unicode, or have big misconceptions about how it works. I'd like to change that, through visualizations and direct links to the data sources (the aforementioned UCD) and links to the Unicode documentation (which is well-written but can be difficult to navigate or even find).

I've worked a lot on it, but I'm totally stuck again. I get too zoomed in and it's hard to see the big picture, plus it's difficult to know how much effort I can realistically put in because I don't know how big the market is. It's a niche tool, but how niche? Would anyone pay for it? But I'm not sure how to do market research, especially for a niche like this. Any advice would be appreciated!

1. The initial idea was based on this post I made in 2024: https://news.ycombinator.com/item?id=42014045

Back in 2020, while federating more than 100 service meshes across on-prem and AWS for a big hybrid cloud project, I had an idea: what if we could "split" the CAP theorem in a way that flips its limitations, enabling massive scaling far beyond traditional consensus protocols? Fast-forward five years:I started prototyping with libp2p, but the networking layer was always just a means to an end; the real goal is that CAP inversion/split for extreme distributed scaling. I think the timing is perfect given current geopolitical pushes.

Super curious to hear thoughts from folks. Any pitfalls I'm missing? Open to feedback or collaborators.

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

Features:

- No sign-up, works entirely in-browser

- Live PDF preview + instant download

- VAT EU support + custom tax format coming very soon

- Shareable invoice links

- Multi-language (10+) & multi-currency

- Stripe and default templates

- Mobile-friendly

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

its a web app where you make boxes, add images or text of what's in the box. then get a qr code that you can tape to the box and scan to see the text or images in the web app.

hoping to make it a lot easier to look for things in the storage unit. instead of removing all the totes and looking in them. Just scan and see if the description fits what I'm looking for

It feels like being able to design my own document format on the fly and display it however I want. It's making it painfully obvious how many editable primitives the web is missing, however.

https://hyperclay.com/

I have been making a micro-arcade of one button games using a fun little library I found.

It is so fun to just have an idea and implement it in under an hour or two. It is a great creative outlet.

Give them a play if you have a second, they are very rough around the edges but are playable on mobile or browser.

https://micro-arcade.netlify.app/

Upload a CSV or circle neighborhoods on Google Maps to build your address list (consumers or businesses). Printing and postage included in one price.

In the last 30 days I've added an API plus integrations for Pipedrive, Zoho, and Follow Up Boss. If anyone wants to help test these new integrations, I'll set you up on a special plan and let you send mail at my cost (roughly the price of a stamp).

The first is a customizable digital math workbook. Currently the demo covers fourth grade math. There is a practice mode where you can select the skills you to want practice. There is also a customizable dashboard where you can setup your own widgets to practice math skills in different ways. I am working on some pre-made dashboards to help users get started. The next plan is to cover fifth grade math skills. My plan is to cover first grade math up to Calculus and High School Physics. I envision it as a companion tool for Khan Academy/Math Class/Math Books. Check out the demo. No signup required. Progress is only stored locally.

https://demo.numerikos.com/

The second thing I am working on is an application to practice Cangjie. It's a Chinese input method that has been around for a long time. It is based on a visual decomposition of characters. Each character is represented by one to five codes and the majority are unique. My application teaches Cangjie like keyboarding (QWERTY) is taught to young students. You learn the location of the keys, then some basic words, then start typing sentences. I also have a free demo for it as well.

https://demo.cangjieworkbook.com

Feedback on either project would be appreciated.

This is the PR: https://github.com/ironcalc/IronCalc/pull/616

Feel free to comment and destroy it!

You can test it in: https://testing.ironcalc.com

I'm recreating Windows 98 desktop GUI faithfully in pure HTML, CSS, and JS, complete with desktop theming, file management, and some programs recreated from scratch or embedded from existing ports.

It started when I was feeling nostalgic and tried to redesign my website with retro style. Then I found 98.css and OS-GUI and got carried away and now it's a full fledged web OS.

There are some accurate recreation attempts like Minesweeper, Media Player and some screensavers, some with my own spin like ChatGPT-enhanced Clippy and Notepad with syntax-highlighting. I also include some well-known projects such as JSPaint, JS-DOS, and many Emscripten ports.

I'm aware that many retro Windows web recreation exist (98.js.org and poolsuite.net are my favorite), but none of them accurately captured the joy of desktop customization that I look for so I made my own version.

Feel free to fork the project here: https://github.com/azayrahmad/azos-second-edition

1. Shifu (https://github.com/emvi/shifu) - a code-based CMS with admin UI. It's really easy to set up, written in Go, free and open-source, and I already sold a few websites using it. It can be used as kind of a framework to build more specialized features into a website and takes away the maintenance hell from managing a WordPress installation or a similiar CMS with tons of plugins that break with every update.

2. Zenko (working title, repo is private for now) - a very simple and no-bullshit project management software. It will be free and open-source, but I might offer a hosted option for a few bucks (like $20/year for all users of a team). I mainly build this for ourself to replace Linear, because we don't really make use of it. Don't get me wrong, Linear is awesome, but we basically only need an advanced Todo list. Main goals:

* Pull updates on the dashboard by yourself, instead of receiving notifications all the time via email

* Keep it simple stupid - no unnecessary features, no AI, just the bare minimum

* Cheap (for the hosted version, free if self-hosted) and easy to host (again written in Go)

* No feature-creep

3. Last but not least, I'm working on a "game engine" written in Go and SDL2. I do this for fun, but it is coming along nicely and teached me a few new concepts already (like ECS in Go).

You can create multiple PocketBase instances for different environments and projects, all with controllable pricing.

We're working on more features, including: - Choosing the PocketBase version to deploy - Editing hook files from the UI - Server monitoring - Creating an on/off Node.js/Deno/Bun project to avoid complex logic in hooks

I am not sure if I will go live with it.

It allows those professionals experts across the USA provide help to Do It yourself consumers for a fee. Consumers can be anywhere.

So I married sort of like Uber (rent skills) + upwork (rent + fees) + FaceTime + e-commerce. realtime audio transcription that identifies parts you need and builds a list for pros and you to review which you then go shop.

: Meet Handy — AI + Live Experts for Every Fix.

: Instant, intelligent home-improvement help — see it, solve it, and shop for it, all in one live session.

Live Video Calls with Pros Instantly connect with verified experts via real-time video. No scheduling hassle — just point your camera and get help.

AI-Powered Visual Assistance HandyLens AI analyzes what the camera sees, highlights problem areas, and guides both consumer and pro with contextual prompts.

Domain Expertise Specialized AI Packs (Plumbing, Electrical, HVAC, Painting, etc.) ensure every session applies the right technical and safety knowledge.

Actionable Fix Path Each call ends with a clear, AI-generated “Fix Report”: what to do, parts needed, and next steps.

Commerce & Trust Built-In Integrates with retailer catalogs for instant part links, and captures verified pro ratings and summaries for quality assurance.

Site where you can read and generate graded Chinese stories, in order to learn Chinese. What's a graded story? It's one written with the vocab of a {X} year old. Words are often repeated, so that you can learn from the left-and-right context. I normally pay for book versions of these, so I thought, why not make one that's online and free?

Minemizer is a data formatter that produces csv-like output, but supports nested and sparse data, is human readable and super simple.

It produces even less tokens than csv for flat data, due to most tokenizers better tokenizing full words that contain a space before the word, and leads to less fragmentation.

There are many cool things I discovered while running tons of testing and benchmarking, but it's getting late here.

Code, benchmarks, tokenization examples and everything else can be found in the repo, but it is still very WIP: https://github.com/ashirviskas/minemizer

Or here: https://ashirviskas.github.io

EDIT: Ignore latency timings and token counts in "LLM Accuracy Summary" in benchmarks as different size datasets were used to generate accuacy numbers while I was running tons of experiments. For accurate compression numbers see compression benchmarks results. Or each benchmark one by one.

I will eventually fix all the benchmark numbers to be representative.

There’s many different solutions out there but I’m carving out a niche where we deal with complex shift assignment problems.

For example one of our customers has specific union rules that need to be followed when assigning work and we ensure that they are compliant.

Our backend relies on an MIP solver as well as heuristic search to refine plans.

I'm literally trying to fix broken junctions around me.

It's at the same time laughably easy, and wildly complicated.

I'm calling the alternative, correct junction a 'traffic bean':

https://josh.works/traffic-bean

It's relevant to software, sorta. I've got rather a lot of GIS/mobility-related data available here. It's just a rails app that renders a bunch of my strava activity data all at once: https://josh.works/mobility-data

The fixes are entirely accomplishable with nothing more high-tech than traffic cones. They can be upgraded to more permanent and pretty physical objects, but the key bit of the traffic bean finds traffic cones fully sufficient. No half-million USD traffic signals, no red/green/yellow light cycles. continuous flow. safety. peace.

Some stuff that's obvious in some domains, like "at high-throughput times, don't allow key bits of infrastructure be completely unusable".

Bringing this to american municipalities is like trying to speak a language with someone that doesn't speak your language, but demands that you treat them as if they do.

it's been a big, long-running project. Most tradition in the USA is really a fig leaf for supremacy, and people can smell that I'm coming for their supremacy a mile away, and they immediately begin deploying emotional defenses.

Or so it seems.

To be clear, there's no benefit to using rust over C for SeL4. SeL4 is formally verified - which provides a level of assurance far beyond what the rust compiler can check at compile time. I'm really just doing it for fun and learning. I've been wanting to really understand sel4 for awhile, and there's something wonderful about learning it from the ground level.

So far, I've got a stub booting. The CPU successfully boots into 64 bit mode and starts running my rust code. I'm starting with x86_64 because thats whats on my desk. At the moment I'm porting the code which locates the root process via multiboot, so I can set everything up in memory correctly.

If anyone is curious, here's the repo: https://github.com/josephg/sel4-rs

Its pretty bare bones for now, but everything starts simple!

EACL (Enterprise Access ControL) is a situated ReBAC authorization library based on SpiceDB, built in Clojure and backed by Datomic. EACL queries offer sub-millisecond query times and has replaced SpiceDB at work (CloudAfrica).

'Situated' here means that your permissions live _next_ to your data in Datomic, which avoids a network hop and avoids syncing to an external AuthZ system like SpiceDB, so all queries are fully consistent.

EACL is fast for typical workloads and is benchmarked against 800k permissioned entities. Once you need more scale or consistency semantics, you can sync your relationships from Datomic to SpiceDB 1-for-1 in near real-time because there is no impedance mismatch between EACL & SpiceDB.

Read the rationale for EACL here: https://eacl.dev/#why-was-eacl-built-the-problem-with-extern...

IMO, if you need fine-grained permissions, EACL is currently best-in-class for the Clojure ecosystem. EACL is especially suited to Electric Clojure applications and can be used to populate menus in real-time.

EACL would not have been possible to build solo in my spare time without modern AI models to rapidly implement specifications and test against human-written tests.

Here is a ~7-minute screen recording of EACL used from an Electric Clojure application for real-time ReBAC queries: https://x.com/PetrusTheron/status/1996344248925294773

It's still early prototype / beta, but wanted to share it anyway!

Most of my time has been spent practically rewriting the engine from just single-screen play areas (like Zelda 1) to be free-scrolling (like Zelda 3). I've also put lots of work into supporting all platforms (was just Windows; now it's also Mac/Linux/Web). And I've delved into tons of interesting programming projects while working on this: a deterministic record + replay testing system; a garbage collector for our custom scripting language; JIT compilers for x64 + WASM; a VS Code language server; the list goes on...

Anyhow, this month I'm trying to polish it up as much as I can so we can officially release the next major version.

It's unfortunate but native UI (as in, using the native controls with their native look) has mostly died off in my opinion, at least for complex cross-platform applications.

You can try to do it in a cross-platform manner but it never works well. Want to implement a tab bar like VSCode's? Win32 tab bars do not support close buttons (need to be custom rendered) and Cocoa tabs it doesn't even make sense for them to have a close button. In Cocoa you're supposed to use either the windowing system to do tabs (similar to Safari tabs) or custom render everything (like iWork).

So I say screw it, make it look as you wish.

The design of the API is somewhat DOM inspired (everything is built up of divs that can be styled). It's pure retained mode for now, I still need to think how I'll make reactivity work.

On macOS it uses a custom NSView to implement "divs". Drawing is done with CoreAnimation layers. Text editing is handled by a nested a NSTextView control with a transparent background. Could also host a web view in a similar manner. Context menus are native.

On Windows it uses a custom C++ class that stores Windows.UI.Composition surfaces for drawing (could also use DirectComposition + Direct2D). Text editing is handled by a windowless RichEdit control (ITextHost/ITextServices). Context menus are native Win32.

On Linux it uses a custom QWidget with a nested QTextEdit control for text editing. I'm thinking of experimenting with Qt Quick for hardware accelerated rendering like the other two.

Yesterday I built most of a Postgres extension, using the excellent pgrx[1] project, that build on ulid to add prefixes. With it you get something like this

    plid=# SELECT gen_plid('u');
             gen_plid
    ---------------------------
     u_06DHRQH6SJT7N2WEQK4910R
    (1 row)

I haven't pushed it to GitHub yet, but it's fairly done at this point.

0: https://github.com/ulid/spec

1: https://github.com/pgcentralfoundation/pgrx

https://github.com/novotimo/tlsproxy

This is still in development (todo are privilege dropping, in place config reloads, log burst suppression, multiple listen sockets (which paired with the Linux kernel gives free load balancing capabilities), and detailed TLS configurability), but it already matches both nginx and HAProxy’s speed (entirely bottlenecked by OpenSSL crypto by this point) at a tiny fraction of the attack surface and memory footprint (10-15kb per worker process last time I checked).

If anyone wants to take a look, please roast my code :)

I'm impressed by how far I can get "vibe making". Most of my professional experience is in high-level software, but AI gets me unstuck quickly when I don't know something specific to ESP-IDF or the hardware. As of today I've got a circuit tested, firmware nearly complete, and a custom PCB en route from JLCPCB.

One limitation I’ve noticed: ChatGPT struggles with the details of part selection (e.g. choosing specific temp/humidity sensors or connectors). Adding datasheets to the context helps a lot, which makes me wonder why this isn’t something the model can do or at least ask for.

Reading practice and assessments for k-12 students, with reporting and tracking for parents, tutors, and teachers. It uses speech to text and quizzes to assess the students reading ability. It picks up skipped words, substituted words, along with metrics on speed and pauses.

I have been testing it with my 2 daughters and its finally at a spot where I don't have to drag them to test it against their will and they are showing improvement. I am working on the marketing now. I have gotten some interest from private tutors but I have a feeling it will be great for the homeschooling community.

Thanks for any feedback! Please leave first reactions as the marketing page is what I am iterating on right now. Don't hold back!

The idea came from cooking bolognese. I needed something to remind me when to stir. So I wrote a small Go tool that just beeps at whatever interval(s) you set.

Then I kept adding stuff. Verbose mode with a live countdown, pause/resume with signals, and a JSON output mode that works with Waybar. That last one is actually my favorite part. I get a little timer in my status bar that changes color when it's counting, paused, or beeping. Click to pause. Works great for pomodoro or just keeping track of things while working.

I switched from Mac to Arch and wanted to try the whole AUR thing. Used GoReleaser to automate the build and publish. Took some fiddling but it works now.

https://github.com/Gioni06/bleep

AUR: yay -S bleep-bin

And sort of in that same vein, I've been developing my own static site generator that I eventually want to move my blog to. It's almost certainly going to be a worse SSG than every alternative, but it'll be mine and that's worth something in itself.

Plus it's just been fun to make! I wrote some gnarly code to generate infinitely nestable layouts that I'm kind of proud of. It's the kind of code that's really cool but you can only code on a project for yourself, because if someone else had to debug it, they might say some pretty unkind things about you.

Om Friday after Thanksgiving I spent half a day building a telegram bot that accepts an address and a list of Amazon links, and in turn orders the item (at a discount since it uses my Amazon credit card), and adds it to the above "family debts" spreadsheet.

I really like the idea of programmable, trusted lending like this, and feel like it could be extended to other groups that you implicitly trust.

We are working on DB Pro, a modern desktop data workbench for developers and data engineers.

The focus is on going beyond a query editor and building a complete environment for working with data. Visual exploration, inline editing, dashboards, and Jupyter notebook style workbooks for queries, notes, and experiments all in one place.

We launched v1 a few weeks ago and the reaction has been genuinely jaw dropping. Downloads, feedback, feature requests, and some great long form discussions around real world data workflows.

We are documenting the entire journey through a public devlog series. The latest video covers the v1 launch.

https://youtu.be/-T4GcJuV1rM

Honestly, building a desktop app is so refreshing after spending a decade or so building web apps.

And I realized I couldn't give a concrete answer. Lots of speculation, but I realized I didn't have hardly any real data. Inspired by Adam Grant's work on "rethinking", I'm _currently_ writing a tiny CLI to run self-experiments on my own productivity, auto-checking in / observing commits/code changes.

Goal at the end is to be able to test myself across different dimensions with "no AI", "moderate AI" (e.g. searching, inline assist), and "full AI" (agents, etc). https://github.com/wellwright-labs/pulse

https://www.tractorfan.us

It’s part of a broader network of niches within the agricultural, heavy equipment and transportation sectors.

It has around 10M pages and pretty decent traffic.

1. probe.bike - tell stories with your bike rides. It allows you to aggregate your cycling trip into one datapoint. Will likely break this out to skiing over the break and rebrand slightly. Adding yearly cards as we speak!

2. flopper.io - I'm seeing traffic rise and rise for this and it's been a great way to translate my every-increasing understanding of AI Infrastructure architecture to a new project. It acts as a benchmark website for GPUs and systems (e.g. Nvidia NVL72.

3. llmstxt.studio - still feel like llms.txt as an idea make sense - so hedged that and but let's see. Got my first customer this month. B2B and need more features/marketing.

4. rides.bike - the oldest - a catalogue or well researched cycling destinations and information about destinations. Will be adding more very soon!

In other words, something safer & more concise than maintaining multiple HashMap's, but a lot less involved & simpler than an in-memory SQLite.

It's better explained by the example here: https://github.com/utdemir/composable-indexes/blob/3baa36762....

https://github.com/utdemir/composable-indexes

I am working on the android version of this app. It is a tiny tool for options trader to see all the premium on one screen. Here is the reddit thread where I initially launched it: https://www.reddit.com/r/Optionswheel/comments/1nlelbp/i_mad...

If you trade stock or options, would love to get your feedback! Thank you.

- Arduino dev and circuitry

- 3D printing

- PCB design

- Woodworking

Its all a lot of fun and IMO a lot more approachable than it has been thanks to the assist from LLMs.

Still WIP but we are getting our first audit in the coming days!

Stoffel-Lang:https://github.com/Stoffel-Labs/Stoffel-Lang StoffelVM: https://github.com/Stoffel-Labs/StoffelVM MPC protocols: github.com/Stoffel-Labs/mpc-protocols Website: stoffelmpc.com

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

Recently it hit v2.0 spec conformance. 3.0 is next on the roadmap. (I'm executing it against the upstream spec test suite.)

I don't plan to make it a highly-performant decoder for use in production environments, but rather one that can be used for educational purposes, easy to read and/or debugging issues with modules. That's why I decided not to offer a streaming API, and why I'll be focusing on things like good errors, good code docs etc.

https://github.com/agis/wadec

P.S. I'm new to the language so any feedback is more than welcome.

I am learning hobby CNC having come from the 3D printer world and I found that the CNC software is considerably more complex than today's 3D printer software.

CNC seems to be the next hobbyist maker boom with the likes of Makera and Nestworks having very successful Kickstarters.

Helping friends (and friends of friends of friends of friends) find their next startup gig without the application process. Aspiring to be Wealthfront for your career… a passive optimization that pings you every now and then with an interesting interview you could take.

Thinking a lot about how to recognize great matches. I think basically everyone can be talented force multipliers in the right situation / company / mission / team. Everyone here wants to do their life’s work, but it’s hard to find it.

Tactically working to scale reliable human-in-the-loop AI recruiter agents with very few humans.

It’s called Riftur, a gap analysis tool that compares two documents and highlights gaps, missing requirements, and inconsistencies. The interesting part for us has been getting the system to understand intent instead of just keywords, so it can flag partial matches and subtle gaps rather than just “present / not present.”

Still early, but it’s been useful in ways we didn’t fully expect. If anyone’s curious, you can demo it out here: https://riftur.com I'm happy to hear thoughts or learn how others handle this kind of review work.

Currently building out support for multi-agent evals, better tracing, voice, and static code analysis for AI security use cases. So many fun sub-problems in this space - LLM testing is deceptively hard.

If you end up checking it out and pick up an issue, I'll happily send swag. We're also hiring if you want to work on this stuff full-time.

https://github.com/promptfoo/promptfoo

The MicroPC is great because it makes it super easy to code and hack on something in places where it would be too awkward or annoying to whip out my laptop, and the Cardputer is just a fun little toy because it's so open ended and hackable. I've been writing an app for Cardputer to control my thermostat remotely, and I've had a lot of fun grossly overengineering the needless amount of concurrency I have added through FreeRTOS.

Something oddly satisfying about using a micro PC to program an "even more micro" PC. What a cool time to be alive; I would have killed for this kind of stuff as a teenager!

Use Case: Assumption: You have access to your friends visitor parking login in Amsterdam.

You are going to a restaurant/or visiting a place near their parking zone(geo fenced polygon). You want to pinpoint a point in map and drive to that point. Being 100% sure that you can park at that point. Automatically pick a meter near there spot and park almost instantaneously. Then this app is for you :D

It's essentially a book progress tracker. There are many apps that allow you to add the books which you are reading currently, but not at what pace. It's simple, no complicated stuff, no AI shenanigans.

Created as I was overwhelmed by the number of books I want to read and thought it would be helpful to plan ahead.

You add a book name, number of pages and how many pages you want to read in a day. It calculates and gives you the number of days and on which date you will finish. It's also flexible to increase the number of pages so that it can recalculate.

It's a PWA for now. Still working on notifications and stuff.

I got frustrated on how difficult it is to compare many elections using alternative voting methods against each other, so ended up extending a friends project, adding more results, details and statistics.

Just added datasette lite to the approval voting site. it’s pretty cool to query the SQLite db in the browser. https://approval.vote/data

I use it as a context fetcher i.e grab an abstract/transcript/thread as clean text/JSON, pipe it into summaries or scripts.

Also runs as an MCP server (experimental), so tools like Claude Desktop or CLI assistants can call the connectors directly.

  arivu fetch hn:38500000
  arivu fetch PMID:12345678
  arivu fetch https://arxiv.org/abs/2301.07041

Then I decided to hack my own ZigBee power meter (to keep track of my meter’s LED pulses) and fought with CMake for eight hours straight, because embedded.

It was a nice weekend.

Started off as an open source alternative to Wispr Flow for myself as I wanted to have more control over the formatting rules as well as model choice but after sharing with friends and presenting it at my local Claude Code meetup, I was encouraged to share it more widely.

The desktop app uses tauri so it is cross-platform compatible and I have tested it working on macOS and windows.

https://github.com/kstonekuan/tambourine-voice

Along the way I found most of these use salvaged BlackBerry keyboards which are only going to become harder to find, so also on a bit of a side quest to build a thumb-sized keyboard from scratch. Got me into laying out and prototyping my first PCBs and learning about how these things are made - lots of fun so far!

Something cool I learned from tearing apart a BB keyboard: the satisfying “click” is just a tiny metal dome that pops and completes the circuit when pressed. Not news to anyone familiar with electronics manufacturing, but it was a cool thing to “discover.”

It's mainly a distraction from enterprise programming, but it does have some parts that might be interesting to Lua programmers, like automated test suits, functional programming point free style and deploying to a raspberrypi via justfile.

The git README kinda doubles as a blog post: https://gitlab.com/michaelzinn/replicide

It's a hobby project I started putting together a couple of months back; a little spot on the internet for prayer and reflection.

Eidetica - a decentralized database built in Rust, intended for local-first apps. It's still unstable but I'm progressing relatively rapidly. In the past ~month I have:

- Flown to SF to attend a conference in this niche: https://syncconf.dev/

- Added password based, transparent, end-to-end encryption

- Improved my custom CRDTs

- Added an index to store configs and metadata

- Built support for using sqlite + postgres for Eideticas backend (not pushed yet)

Once I finish the backend work I'll hopefully take a bit of a break though. I'm supposed to be retired.

Turns out it was a common pain point. Now it has around 800 users in Chrome+Firefox. Mostly chrome.

https://github.com/gediz/teams-web-chat-exporter

- https://github.com/yassi/dj-redis-panel - https://github.com/yassi/dj-cache-panel

This week I'm taking a break from my next project in this series (celery related) to try to participate in game jam related to programming language creation:

- https://itch.io/jam/langjamgamejam

I encourage others to participate I e

A big part of this was inspired by the last startup I worked at. In an effort to not deal with complexities of Kubernetes, we ended up on Heroku and was charged exorbitant amounts of money. One year spending close to 400k on Heroku alone, for what should’ve been 10-15k in cloud costs.

I think a big part of this is just making Kubernetes more friendly and easier to use for a small / midsized team of developers.

The goal is to make it easy enough for even a single developer to feel comfortable with, while also being powerful enough to be able to support a small team

And as everyone now, I'm experimenting with LLMs to bring some new AI-related features to the service.

On another project, we've now beta testing (in ordination) Asus GX10 processing power running on-device LLMs for _local_ processing of patient medical data for 'differential diagnoses, implant plans and risk profiles in real time while the patient is in still in the chair'.

[1] https://MLSync.io

I doubt it'll be of interest to folks here - but my Family recently (in the last couple of years) started to breed ragdoll cats in the U.K.

This has been my personal project to understand where I personally find LLMs useful as coding assistants, and where I don't. One easy to spot example is, front-end + copy. Another area I've enjoyed it is talking through how I'd design and build functionality and features ahead of time.

It's been very interesting, and is helpful to folks I care about, even if no-one else ends up using it!

It's in a pretty early stage of development though, I haven't added my samples yet and nothing is to scale. It does run though which is neat https://github.com/thansen0/seabed-sim-chrono

It aggregates data from across the web into a single feed, pulling in news, weather, newsletters, social posts, Reddit, YouTube, and more.

I also finally launched my first iOS app that goes a step further. During onboarding, you set your preferences once. From there, AI automatically prepares your daily digest for you. Each morning, you get a notification when it’s ready, with everything relevant for the day ahead: meetings, weather, health data, commute insights, and the news you actually care about.

Updated manually so expect some delay :)

The goal is to help small teams and fast-growing startups understand where cloud spend is leaking and automatically reduce waste (idle resources, over-provisioned workloads, inefficient Kubernetes setups, and AI API usage). Setup is lightweight, and we focus on actionable recommendations rather than massive dashboards.

We’re still early and testing with a few teams who want better cost visibility without running a full FinOps practice.

Website: https://deepcost.ai

It feels like somewhere in the last decade we've all lost control over our email inboxes. While it would certainly be possible to filter and sort it, I've been wondering if it makes sense to just start with a system that is designed to intake a bunch of streams of information. Then it could be pointed at the raw information e.g event calendars and news-letters as well as streams like Facebook groups/Instagram where I don't want to actually go to those apps.

Speaking at a meta-level, this seems like what we should really be using LLMs for right now: use-cases where user controls what is done on their behalf.

A different type of job search site that gathers job postings direct from company websites. About 1 in 4 jobs are not advertised on any sites (like LinkedIn or Indeed) but they are found going direct to company career page.

Side note: I found my last gig using this method so have now built it into a web app. It is a paid service but feel free to DM me for a free trial.

It's intended to be anti-memetic, and anti-guilt trip. Just put it on your watch, install a program (open format) and you never need the phone itself. Your workout is a holiday from your phone.

The data can be exported if you want to use it elsewhere.

I originally made it for ROCKNIX but as there was no way to share the app I paid the Apple tax :/

https://github.com/jmahmood/RED-STAR-WEIGHTLIFTING

I started this over the summer when I was moving to a new house and wanted to document the family history behind some thing I own. It's turned out to be more useful than I thought and I've expanded the features as friends found it useful. A developer friend, who I used to work with, joined me and we're both working on it now. It does have a little revenue now but we are far from quitting our day jobs.

I'd really like any feedback from the HN community!

This allows library authors to do more, like defining webhook handlers and (simple) database operations. The idea is to move complexity from the library user to the author, making (API) integrations easier.

I think libraries being able to write to your database is a pretty powerful concept, and can enable a number of interesting use cases.

https://github.com/rejot-dev/fragno

It allows users to "chat" with their Logseq graph. Think of it like a "Cursor for Logseq". I hope people find it useful. I have on numerous occasion wished that I could have easily asked about a specific block on my graph, and would provide an intelligent response, also somewhat influenced by the contents of the entire graph. It's still a work in progress.

It's fully open source.

Now I feel lost, I don’t know where to go from here. I don’t even know if I am doing the right thing. What do you think? Is there any guidance or roast you can give? Here is the website https://www.racetoagi.org/

Here is the trends collection https://www.racetoagi.org/trends

Here is the deals graph https://www.racetoagi.org/deals

Finally, here is the newsletter https://www.racetoagi.org/research/newsletter

One terrifying piece of news I saw today https://www.racetoagi.org/news/2025-12-15-japanese-local-med...

I built a PWA that feeds you random, high-engagement Wikipedia topics (like the Great Emu War or the Demon Core) in a swipeable deck. Swipe right to save, swipe up to read "trivia snacks" instead of the full article. The idea was to have an antidote to doom scrolling.

The project started at a "vibe-coding-hackathon" and is now starting to become my main side project.

Curious for feedback :)

https://swipedia.surge.sh/

I wrote about it here: https://pcmaffey.com/custom-ssg/

Forkable template: https://github.com/pcmaffey/bun-ssg

open source browser first server-less markdown document workspace and publisher, contending to be a free obsidian alternative

storage is done in indexeddb or it can utilize opfs to work on a local file directory

comes with git integration

can publish to aws cloudflare vercel and github pages

built with shadcn react and typescript

Basically I long wanted to plug a chatbot into my messenger of choice with all sorts of tools for quick use, of course after the emergence of LLMs it was only a matter of time before I find time for it.

As an experiment I have decided to use Claude code + opencode to develop it, and after some trial and error I am very thoroughly impressed with the results, it grew to a nearly 10k LOC in a week and it is still very much manageable, I haven't changed a single line of code manually still.

I have developed it as a "core" that imports modules with a rigid and thoroughly documented in a spec.MD file interface, and every single bit of functionality essentially acts as a different sub-app that can consume events that trigger it and handle all of the internal logic within itself, that way everything is separated nicely and totally manageable within LLM context.

It does everything from setting up and sending reminders and todo lists, helping me track car mileage and fuel consumption, getting an overview of the day ahead(sometimes if task is important even a reminder few days prior to its date), to even opening my front gate. And all of that is exposed to 'core' chat module through tool calls, so I can request anything in plain English or voice.

Also has a web-ui where I can review tasks, reminders, settings or search past conversations.

Been using it a lot, and since I'm using groq for inference, I still haven't even needed to pay a thing, since it fits within the free limits

I'm building a session prep tool for tabletop RPG game masters. The idea is to make a narrative engine rather than another static wiki. Most existing tools are great for storing lore, but they don't help you run the story. I wanted something that supports the "create now, refine later" workflow — get ideas into structure fast, then refine as you play.

Core features: - interconnected world-building (NPCs, factions, locations) and story-building (situations, fronts, clocks) - Bidirectional linking — connecting a story hook to an NPC makes that hook visible from the NPC's view - Clock system with milestone consequences that can spawn or edit entities - Situations fire different consequences based on outcome (players engaged vs. ignored the hook) - Material waste detection — flags under-connected content so you know what's prepped but unused.

The main workflow is mindmap-based. Each entity gets its own context layer showing direct relationships. (Soon available in demo version) Working on next: automatic player-facing content. As players complete situations, public notes from involved entities get published — so the GM doesn't have to maintain a separate campaign log.

Stack: TypeScript, Effect-TS, SolidJS, Cytoscape (graphs), Leaflet (maps)

The hosted version is rough — I've been using it to get early feedback from GM friends. Happy to hear thoughts from anyone who preps campaigns

However had, on my todo list ... a few things that are important to me are there.

One is to create some kind of pseudo-language that can model biological cells, from A to Z. I am having something similar to erlang in mind (to some extent). Now, this is nothing new - modeling is quite old, bioinformatics is old, but I have a few ideas that are somewhat novel IMO (e. g. really following erlang here, just adapted to biological systems).

Then I have a few smaller ideas. One is to finish a webframework where everything is really an object at all times. Meaning, I can work with objects when describing a webpage, from A to Z. HTML tags are objects too. I don't typically use them directly, though, but more in a meta-layout, e. g. I want to describe a webpage, but on a higher level, and also push that down into a .pdf file then seamlessly. My goal here is to be able to work with objects everywhere, not just for a single webpage but for all local and remote webpages, a bit similar to Alan Kay's old ideas.

I have a couple more ideas (one is the widgets project where I want to describe a GUI only once and then have it work in as many variants and languages as possible), but realistically I also focus on the smaller things to do as they are much easier to solve. Right now it is more important to me to finish as much as possible before the end of the year, so prioritising on smaller things makes more sense.

The site isn't even online, but for now I'm starting to think about the next steps (seo-related things to implement, generalize app functions to handle not only blog but other (hypothetical) apps as well, improve code quality and repo readability, separate apps from the website so anyone can add them to their django website if they want to). It's a lot of work for something no one will ever use, but I must at least try to make it clean and discoverable :)

- I’ve just started designs and initial setup for a personal productivity system heavily inspired by the Newton & HyperCard and built in Rust. Idea is to use LLMs to build GraphRAG-like connections between content & break out of the standard app+document model. My current thinking is having ‘frames’ of content (notes, sketches, events etc) that are acted on by capabilities and displayed in views (timeline, calendar, stack, knowledge graph etc).

- Also working on a static site generator and CMS webapp that creates sites that can be viewed on anything, from web browser to TUI. Like if Gemini or Gopher also rendered to html.

I recently integrated Lazy Polars and running analytics in background processes so I can reliably provide a fast table viewing experience on dataframes that would normally exhaust memory of the jupyter kernel. Analytics are run column by column and results are written to cache, if a column fits into memory individually, summary stats for the entire dataframe can be computed.

Here's a demo video of scrolling through 19M rows, and running background summary stats.

https://www.youtube.com/shorts/x1UnW4Y_tOk

An AI coding tool desktop application written in Rust and Javascript. Cursor, Windsurf and etc uses too much memory on my machine. As an engineer it is important that the tools I use daily are performant and fast and I could use while watching a youtube video or browse hackernews.

While working on the tool I am building some boilerplates to start from, starting with mobile games targeting arcade games like Flappy Bird.

"But there are many already!" I hear the crowd exclaim.

I respond, "Yes, but..."

It's really something I want for myself. Lightweight, as fast as humanly possible, extensible via plugins (in fact the entire app is mostly plugins, with a small core to glue it together), and a tiny bit of LLM (call it AI if you wish) integration to ask questions about the database or generate/review queries.

https://estonianstartupjobs.ee

The simplest web framework and site generator yet – no leaky abstractions between you and the high-performance engine that is a modern browser.