Ask HN: What are you working on? (March 2025)

Labeled data is the bottleneck, so my work focuses on getting good results with less data. Key parts:

- Created EDANSA [1], the first public dataset of its kind from these areas, using a improved active learning method (ensemble disagreement) to efficiently find rare sounds.

- Explored other low-resource ML: transfer learning, data valuation (using Shapley values), cross-modal learning (using satellite weather data to train audio models), and testing the reasoning abilities of MLLMs on audio (spoiler: they struggle!).

  Happy to discuss any part!

Would love to hear any feedback the HN crowd has. I'm aware of a couple of alignment issues, will fix them up tonight. Also, yes, there will be a "generate PDF" button, for now if you want a pdf I'd suggest using the Print dialog to "Save as PDF".

https://bestfreeinvoice.com

pure.md acts as a global caching layer between LLMs and web content. I like to think of it like a CDN for LLMs, similar to how Cloudinary is a CDN for images.

[1] https://pure.md

I wanted to understand how models learn, like literally bridging the gap between mathematical formulas and high-level API calls. I feel like, as a beginner in machine learning, it's important to strip away the abstractions and understand how these libraries work from the ground up before leveraging these "high-level" libraries such as PyTorch and Tensorflow. Oh I also wrote a blog post [5] on the journey.

[1] https://github.com/workofart/ml-by-hand

[2] https://github.com/karpathy/micrograd

[3] https://github.com/workofart/ml-by-hand/blob/main/examples/c...

[4] https://github.com/workofart/ml-by-hand/blob/main/examples/g...

[5] https://www.henrypan.com/blog/2025-02-06-ml-by-hand/

I love card games, but for digital card games the business model is beyond predatory. If you need a specific card your option is to basically buy a pack. Let’s say this is about 3$ give or take. But if it’s a specific rare card, you can open a dozen of so packs and still not get the specific card you want.

This can go on indefinitely, and apologists will claim you can just work around this, by building a different deck. But the business model clearly wants you to drop 50 to 100$ just to get a single card.

All for this to repeat every 3 months when they introduce new mechanics to nerf the old cards or just rotate out the dream deck you spent 100$+ to build.

I’m under no impression I’ll directly compete, but it’s a fun FOSS game you can spin up with friends. Or even since it’s all MIT, you can fork and sell.

It also gives me an excuse to use Python, looks like Django on the backend and Godot for the game client. Although the actual logic runs in Django so you can always roll a different game client.

Eventually I’d like different devs to roll their own game clients in whatever framework they want.

Want to play from the CLI, sure

I think virtual tabletops (VTTs) as they currently stand are barking up the wrong tree[2]. I want a computer-augmented RPG to allow the GM to do everything he does in the analog form of the game. On-the-fly addition of content to the game world, defining of new kinds of content, defining and editing rules, and many other things ... as well as the stuff VTTs do, of course. The closest we've gotten in the last 30 years is LambdaMOO and other MUDs.

The app I made for my thesis project was an experimental vertical slice of the kinds of functionality I want. The app I made after that last year is more practical and focused on the needs of my weekly game, in my custom system; I continue to develop it almost daily.

I'm itching to tackle the hardest problem of all, which is fully incorporating game rules in a not-totally-hardcoded way. I need rules to be first-class objects that can be programmatically reasoned about to do cool things like "use the Common Lisp condition system to present end user GMs with strategies for recovering from buggy rules." Inspirations include the Inform 7 rulebook system.

[1] See my homepage, under Greatest Hits: https://www.mxjn.me

[2] Anything that requires physical equipment other than dice and a regular computer is also barking up the wrong tree. So no VR, no video-tracked physical miniatures, no custom-designed tabletop, no Microsoft Surface... Again, just my opinion.

It's been a fun project. Dealing with the scale of Reddit (~300 posts/second) creates some interesting technical challenges. It's also let me polish up my frontend development skills.

I don't think it will ever be a money spinner - it has ~70 folks using it buy they're all on the free tier. It's felt really good to build something useful, though.

[1]: https://mentions.us

I built a no-AI, human-only social network focused on ONLY one thing - keeping people connected.

I'd stepped away from mainstream social media last year due to the overwhelming negativity, privacy violation, etc. Then around early this year, I started to feel I was missing updates from people who actually matter in my life. Instead of going back to traditional platforms, I decided to create a simple solution myself.

The platform emphasizes: - No AI algorithms or content manipulation - No infinite scrolling designed to trap your attention - A simple interface for sharing life updates with close connections (Text and Photos only for now)

We've intentionally made connecting difficult: no user search and no friend suggestions - you only connect with people you already know and care about.

Web: https://aponlink.com/ Android App: https://play.google.com/store/apps/details?id=com.aponlink.a... (iOS version coming soon)

I'd love to hear how this approach resonates with the HN community, particularly from those who've also grown tired of traditional social media.

You can read an intro here: https://blog.tangled.sh/intro (it’s publicly available now, not invite-only).

In short, at the core of Tangled is what we call “knots”; they’re lightweight, headless servers that serve up your git repository, and the contents viewed and collaborated upon via the “app view” at tangled.sh. All social data (issues, comments, PRs, other repo metadata) is stored “on-proto”—in your AT Protocol PDS.

We don’t just plan to reimplement GitHub, but rethink and improve on the status quo. For instance, we plan to make stacked PRs and stacked diff-based reviews first-class citizens of the platform.

Right now, our pull request feature is rather simplistic but very useful still: you paste your git diff output, and “resubmit” for a new round of review (if necessary). You can see an example here: https://tangled.sh/@tangled.sh/core/pulls/14

We’re fully open source: https://tangled.sh/@tangled.sh/core and are actively building. Come check it out!

On YouTube: https://youtube.com/@foxev-content

In a learning app: https://foxev.io/academy/

On a physical board where people can explore electric car tech on their desk: https://foxev.io/ev-mastermind-kit/

Backstory: from 2018-2023 I converted London taxis to be electric and built three prototypes. We also raised £300k and were featured in The Guardian. I have a day-job again these days and am persisting what I learnt and sharing it. YouTube is super interesting for me because of the writing, similar for the web app actually because the code isn't that complicated, it's about how do I present it in a way that engaged users, so I am thinking mostly about UX.

Actually why not, here is the intro to the first module (100 questions about batteries - ends in a 404): https://foxev.io/academy/modules/1/

[Edit]: I wrote a re-introduction to Runno: The WebComponent for Code over the weekend (https://runno.dev/articles/web-component/)

I've been playing around with turning it into a sandbox for running code in Python (https://runno.dev/articles/sandbox-python/). This would allow you to safely execute AI generated code.

Generally thinking about more ways to run code in sandbox environments, as I think this will become more important as we are generating a lot of "untrusted" code using Gen AI.

For my day job I am currently working for an online education company. I have been learning about the concepts behind knowledge tracing and using knowledge components to get a fine grained perspective on what types of skills someone has acquired throughout their learning path. It is hard because our company hasn't really had any sort of basis to start from, so I have been reading a lot of research papers and trying to understand, from sort of first principles, how to approach this problem. It has been a fun challenge.

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

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

I'm excited.

It lets users merge two or more workouts into a single one. There have been times when I have been out riding, hiking or whatever and accidentally end the activity on my apple watch instead of pausing it. Starting a new workout means having your stats split across the two workouts.

The "usual" way to merge such workouts is to export all of them to individual FIT files, then use a tool like fitfiletools.com to merge the individual FIT files. You then have a merged FIT file, which is difficult to import back into Apple Health. This process also requires access to the internet, which is not always guaranteed when out in remote areas.

MergeFit makes this process easy by merging workouts right on device and without the need to deal with FIT files at all. It reads data directly from Apple Health and writes the merged data back to Apple Health.

The app reached a small milestone a few days ago - crossing 1000$ in total sales.

I recently completed Valence: a language with polysemantic programs https://danieltemkin.com/Esolangs/Valence on GitHub: https://github.com/rottytooth/Valence

Older work includes Folders: code written as a pattern of folders: https://github.com/rottytooth/Folders , Entropy: where data decays each time it’s read from or written to: http://entropy-lang.org/ and Olympus: where code is written as prayer to Greek gods, who may or may not carry out your wishes: https://github.com/rottytooth/Olympus (a way to reverse the power structure of code, among other things).

I have three more to complete in the next few months.

here's a screenshot:

https://gist.github.com/1cg/e99206f5d7b7b68ebcc8b813d54a0d38

An electronic board game similar to Settlers of Catan (https://github.com/seanboyce/Calculus-the-game), just received the much better full sized boards. Will assemble and test over the next few weeks, then document properly. I got the matte black PCBs, they look really cool.

A hardware quantum RNG. Made a mistake in the board power supply, but it still works well with cut trace and a bodge wire. Will probably fix the bug and put the results up in a few weeks. Can push out ~300 bytes of entropy a second, each as an MQTT message.

A hardware device that just does E2E encrypted chat (using Curve 25519). Microcontrollers only, no OS, and nothing ever stored locally. HDMI output (1024x768), Wi-Fi, and USB keyboard support. I originally designed it to use a vanilla MQTT broker, but I'm probably going to move it to HTTP and just write a little self-hosted HTTP service that handles message routing and ephemeral key registration. Right now the encryption, video output, and USB host works -- but it was a tangle of wires to fix the initial bugs, so I ordered new boards. Got to put those through testing, then move on to writing the server.

Iterating on hardware stuff is pretty slow. I try to test more than one bugfix in parallel on the same board. Iteration time is 2-3 weeks and 8$. If I have all the parts in stock. I don't have very much free time right now due to work, so this suits me fine. A rule I live by is that I must always be creating, so I think this is a reasonable compromise.

Its main differentiator: hover any thumbnail (homepage, search, shorts, etc.) for an instant mini-summary, like Wikipedia link previews. Also includes detailed summaries w/ timestamps, chat w/ video, chat w/ entire channels, and comment summaries.

Hover & Detailed summaries are free if you plug in your own OpenAI API key ("free for nerds" mode).

Aiming to be the best YouTube-specific AI tool. Would love your feedback. No signup needed for free tier/BYOK. If you try it and email me ([redacted]), happy to give you extended Pro access!

A ray-casting engine is an old style of game engine (think 1990 - Wolfenstein or Duke Nukem). The most famous, well-known example is probably Wolfenstein-3D created by ID software (John Carmack and John Romero etc!) You don’t see these engines used anymore in modern games.

So to me, they are novel and a great challenge to try and modernise. Especially as a solo dev! And for further context, raycasted levels are usually teeny tiny (Wolfenstein 3D or Shadow Warrior are the largest worlds I’ve seen, so nothing impressively scaled). I have never ever come across a raycaster with levels the scale of something like Minecraft. So that’s what my ambition is.

I spent a period of 2-3 months roughly 8-10 hour days every day on this project, not knowing much C and not knowing anything about game engines or graphics, and average at mathematics.

But I’m on a break from the project and coding after my 7 year relationship broke down. Realised I had tunnel vision with my life and ambitions, and am now “touching grass” daily instead. It’s hard to put effort into your hobbies when you feel other areas of your life are suffering.

So now I’m lifting weights and doing cardio and reading books instead, trying to keep active and my mind occupied.

I do want to pick this project back up, I’m really proud of what I was able to achieve with no knowledge coming in and I think the project has good bones.

And I loved coding, still haven’t found a hobby that scratches a similar itch

[0] - https://github.com/con-dog/chunked-z-level-raycaster/blob/ma...

The idea is simple: if your app can send an email, it can trigger notifications across multiple channels with no extra coding. Think of it as "SMTP Server to Anything."

One of the cool parts is MailTrigger supports WebAssembly (WASM), so you can customize your own notification logic and automate workflows. I’ve used it for tasks like monitoring internal systems, forwarding alerts to different chat platforms, and even adding basic decision-making logic before sending notifications. It’s been a huge time saver.

I’ve also experimented with using LLMs to assist in rule creation — you can configure notification rules using natural language instead of writing manual code. It’s like giving your infrastructure a smarter way to handle incidents.

At my company, I’m using MailTrigger for real-time price drop alerts and server health monitoring, along with integrations like Jenkins and Sentry to forward alerts to our DevOps Telegram channel.

It’s still super early, and things like the docs, pricing, and overall user experience are definitely a work in progress. But I’m iterating quickly and would love to hear feedback from this community!

Check it out here: https://mailtrigger.app/

Curious to hear your thoughts!

I often read about interesting public companies (from an investment perspective or otherwise), but fail to then keep up with them over time (sometimes reading many months/years later how successful they were - or not!). I built this to make an easy way for me to follow updates from said companies.

https://www.assetroom.net/

Key updates from the past month:

- New demo screencast [2]: Deploy a highly available web app with automatic HTTPS across cloud VMs and on-premises in just a couple minutes

- Added initial Docker Compose support for service deployment. The same Compose can be used for developing locally and deploying to your cluster

- Completely revamped how service and container specifications are stored, enabling proper implementation of the service 'scale' command and selective container recreation

My goal for Uncloud is to create a more capable and modern replacement for Docker Swarm, which is no longer being actively developed.

[1]: https://github.com/psviderski/uncloud

[2]: https://github.com/psviderski/uncloud?tab=readme-ov-file#-qu...

In addition to the code assistant, I configured a Grafana's MCP server with Cline, so that I can chat with an LLM while having real-time metrics and logs.

For context, I self host grafana in addition to a bunch of services on a raspberry pi. Simple prompts such as "why has CPU been increasing this week?" resulted in a deep analysis of logs/metrics that uncovered correlations I had never been aware of.

Incredible. I can only imagine what this will all look like in a few years

It’s a TypeScript web framework that’s runtime agnostic, so it can work on serverless and servers (similar to Hono).

What’s different is that the focus is primarily just on TypeScript. There’s a CLI tool that inspects all the project code and generates loads of metadata. This can include:

• services used

• all the HTTP routes, inputs and outputs

• OpenAPI documentation

• schemas to validate against

• typed fetch client

• typed WebSocket client (and more)

The design decision was also to make it follow a function-based approach, which means your product code is just functions (that get given all the services required). And you have controllers that wire them up to different transport protocols.

This allows interesting design concepts, like writing WebSocket code via serverless format, while allowing it to be deployed via a single process or distributed/serverless. Or progressive enhancement, allowing backend functions to work as HTTP, but also work via Server-Sent Events if a stream is provided.

It also allows functions to be called directly from Next.js and full-stack development frameworks without needing to run on a separate server or use their API endpoints (not a huge advocate, but it helps a lot with SSR). Gave a talk about that last week at the Node.js meetup in Berlin.

It’s still not 1.0 and there are breaking changes while I include more use cases.

Upcoming changes:

• use Request and Response objects to make it truly runtime agnostic (currently each adapter has its own thin layer, which tbf is still needed by many that don’t adopt the web spec)

• smarter code splitting (this will reduce bundle size by tree-shaking anything not needed on a per-function basis)

• queues (one more form of transport)

Check it out, would love feedback!

We'll have about ~300 short audio clips to record, and we'll store/access them via an SPI SD card reader peripheral. Audio output via a MAX98357A combo DAC/class D amplifier that we'll talk to via I2S. Powered by 2 AA batteries. Programming will be in CircuitPython, which is a cool way to teach the kids programming. (There are easy libraries for talking to all those peripherals.)

The real key here is how migrations over time are handled seamlessly and effortlessly. Never again do you have to meet with half a dozen teams to see what a field does and if you still need it - you can identify all the logic affecting the field and all the history of every change on the field and create a mapping. Then deploy and the system migrated data on the fly as needed.

Still in stealth mode and private github but the launch is coming.

Also, I've recently picked up modeling my financial choices and circumstances in Python. Modeling uncertainty is especially interesting I've found. I might share the Jupyter notebook some time to get some feedback.

PUGs need a way to communicate and broadcast, to be discovered, but it doesn't necessarily need all of Meetup's features. Also, PUGs probably don't want to be tied to Facebook or other social media platforms. It'd be best if they allowed a simple ownership transfer, once you get tired of organizing.

That's why I created https://pythonuser.group/ - a lightweight side project that, despite being rough around the edges, fulfills the core need: allowing people to discover PUGs worldwide for free. The platform costs me almost nothing to maintain. Allows to subscribe to local PUGs via RSS (not sure if it works). I'll add "export all my PUG data" once someone requests this feature.

It's the first time I share it with the world. Please don't treat it as prod-ready. Feedback welcome at hn@{username}.com

See here: https://imgur.com/a/e3Xo9Io

Carimbo source code: https://github.com/willtobyte/carimbo

More information: https://nullonerror.org/2024/10/08/my-first-game-with-carimb...

Started as a personal pain after moving to the US. Now works for both people and businesses. Built our own voice infra. iOS, Android for B2C, and web dashboard for B2B. Building full-time with my wife – just pushed the first version of the mobile app this week.

https://cail.io

For younger kids I've modified Overcooked 2, a traditionally co-op game. I've replaced the second player with a visual scripting platform that allows kids to code their way through levels — worth noting I haven't removed co-op, there's still room for 2 other players:

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

For older kids I've been making contributions to GodotJS, which allows you to build games in Godot using TypeScript rather than GDScript. GDScript is pretty nice, but I want to be able to teach kids skills that are more directly transferable to different domains e.g. web development:

https://github.com/godotjs/GodotJS/pull/65

I used to be Head of Engineering at Ender, where we ran custom Minecraft servers for kids: https://joinender.com/ and prior to that I was Head of Engineering at Prequel / Beta Camp, where we ran courses that helped teenagers learn about entrepreneurship: https://www.beta.camp/. During peak COVID I also ran a social emotion development book subscription service with my wife, a primary school teacher.

Therefore, I‘m working on a mid- to longform blog post that details how precisely the competencies that senior developers and tech leads already have are the key to fully harness the potential of these tools.

And who knows, maybe I‘m going to develop this into some form of consulting or training side project.

I've been working on building a programming method for biology labs. Basically, it is a dynamic execution environment using lua that can have full rewind-ability (for complete execution tracing) and pausing - you can execute some code then wait a week or so to continue execution. The idea is you can have a dynamic environment for executing biology experiments where the route changes on the basis of outcomes - something I haven't really seen anywhere else. Then I focused a bit on the pedagogy of LLMs so that you can ask an LLM to generate a protocol, and then when you execute it and get unexpected results, it can automatically debug its own protocol using a code sandbox.

It all sounds decent in theory but the difference is I actually implemented it and ran a real biology experiment with it (albeit a simple one that I knew wouldn't work)

Demo here: https://github.com/koeng101/autodemo (probably watch the video)

To start with, there's https://nuenki.app. It's a browser extension that selectively translates sentences into the language you're learning, so you're constantly immersing yourself in text at your knowledge level.

I've also been working with a friend on a device to help blind people without light perception. I'm quite new to electronics. It's pretty simple, conceptually - a coin-sized device on the forehead that takes in the light intensity in a ~15 degree cone, then translates it into high resolution haptic feedback to the forehead.

The idea being that it means people without light perception can gain a sixth sense through neuroplasticity, with helps them navigate the room and understand their surroundings. We're planning on open sourcing the files. My mum used to teach blind kids, and there's been quite a lot of interest!

As for Nuenki, I'm pretty bad at marketing, so I'm doing a final lot of work to see if I can make it work financially - seeing if an exceptionally generous affiliate program will do the trick - before putting it on maintenance mode, since I have a small group of users who really like it. I'm burning through my gap year fast, and really want to focus on the electronics project, tutoring, and practicing maths for my physics degree.

I wanted a better way to keep track of applications I sent out, A spreadsheet just seemed like a poor way of tracking data. So overtime I built a desktop application to track my job search activity for me. Most alternatives are web-based, but I didn’t love the idea of broadcasting my job search to third parties. This is a native desktop app (Windows/macOS) that keeps everything local.

Still working on code signing (so no scary "unknown publisher" warnings), but otherwise, v1 is ready.

Would love feedback—especially from others who’ve struggled with job-search tracking!