value: jothetaha

value:
Convosphere is a location-based chat app where you can join local conversations, events, and meet people nearby — all without sharing personal data.
Main features:
• GeoChat: join or create chats within a custom radius.
• TrustScore: reputation system to keep conversations safe.
• Events: discover or host local activities.
• AI integration: Sfera AI curates local news and creates events based on them.
• Teleport mode: explore chats from any city.
Available for Android, iOS and Web: https://convosphere.app
I'd love to hear feedback, especially about improving onboarding and local discovery.

value: Show HN: Convosphere – GeoChat app to talk with people nearby anonymously

author: jothetaha


value: askadityapandey

value: Show HN: I analyzed 44 OSS dev tools revenue model matters more than stars

author: askadityapandey


value: rokontech

value: PR Test Review & Enhancement – AI that reviews your tests in PRs and suggests missing cases and needed improvements

value: Show HN: AI Test Reviewer for PRs – Finds gaps in your existing tests

author: rokontech


value: omermorad

value:
Hey HN!
Suites is a unit-testing framework for TypeScript backend systems working with dependency injection.
It introduces a single declarative API for unit testing: wrap any unit with a single call and receive a correct test environment for the unit and its dependencies.

  // Test a class in complete isolation, all dependencies mocked
  TestBed.solitary(OrderService).compile();

  // Or, test how it integrates with a real dependency
  TestBed.sociable(OrderService)
    .expose(PaymentProcessor) // Use the real class
    .compile();

The backstory: while working for a fast-growing fintech startup 4 years ago, my team had to write thousands of unit tests for our NestJS backend. To scale our efforts, I've built a unit-testing framework which eliminated a significant part of the tests' code and made them a whole lot more maintainable. I open-sourced it, generalized it to support more tech stacks, and soon it gained traction.
The problem - unit testing becomes a nightmare very fast:
- You mock dependencies by hand, wire them up manually, and spend more time maintaining tests than writing them.
 - Unit tests are leaky and error-prone since it's unclear which dependencies are mocked
 - Test intention is lost in the boilerplate
 - Each engineer invents their own conventions
 - Tests break during refactors because of untyped, loosely connected mocks
 - Missing mock implementations go unnoticed, so tests falsely fail on unexpected undefined returns or validate the wrong behavior
 - Test errors for wrong mocking are confusing to engineers and coding agents alike
The nitty-gritty details:
- Fluent, auto-discoverable, fully-typed API.
 - DI Framework Adapters: Works out of the box with NestJS and InversifyJS
 - Testing Library Adapters: Works out of the box with Jest, Sinon, and Vitest
Suites provide two modes of testing: (inspired by Martin Fowler's writings [0])
- Solitary: For testing units in a vacuum, it creates type-safe mocks of all the unit's direct dependencies.
 - Sociable: For testing units with other related units, it allows the developer to define which dependencies to mock.
Eliminating boilerplate and making mocks type-safe drastically helps coding agents (e.g. Claude Code) to write correct tests in a single pass and avoid entering infinite loops, significantly reducing token cost.
You can read more about Suites on our website: https://suites.dev
What's next?
-  A dedicated skill for Claude Code
 -  Extended docs with real-world patterns
 -  More test utilities for common backend scenarios
Suites is fully open-source and actively maintained for 4 years. I would love you to check it out and get your honest feedback!
[0] https://martinfowler.com/bliki/UnitTest.html

value: Show HN: Suites – modern unit tests framework for TypeScript back ends

author: omermorad


value: Show HN: Bulk images compressor work in the browser


value: drschlange

value:
Hi HN! I'm Vince. I built Nallely, a modular reactive Python framework for creating custom MIDI instruments by patching signal-processing modules together, like a modular synthesizer for controls systems. Nallely focuses on real-time, thread-isolated, reactive behavior, letting you experiment with emergent behaviors.
Demo video: https://www.youtube.com/watch?v=rbMnKAdqAVI building a patch from scratch and hot-debugging a running instance near the end.
Key features:
* Visual patching interface for connecting reactive modules (neurons),
* Extensible via Python API, WebSocket, and/or code generation,
* Integrates any input source (MIDI, webcam, ...) to control synthesizers.
# Yes, but why?
Existing software/libraries that proposes MIDI manipulation are powerful but not friendly to live experimentation. They are low-level, hard to rewire on the fly, and often heavy for embedded or headless setups. I wanted a system that could also evolve dynamically where modules could be patched, hot-swapped, and debugged in real time.
# Architecture
The system is built around a reactive threading model with no shared data: each neuron lives in its own thread and communicates by sending messages through channels. No more CC,... , at the neuron level, everything is a signal (a simple int/float value through time). No global tick, each neuron works on its own time. Each neuron being reactive, they are sleeping the majority of the time. The system takes heavy inspiration from the "Systems as Living Things" philosophy and Smalltalk by treating each thread as a small living entity more than a processing unit. Here is how to code a simple Sample&Hold module:

    class SampleHold(VirtualDevice):
      input_cv = VirtualParameter(name="input", range=(0, 127))
      trigger_cv = VirtualParameter(name="trigger", range=(0, 1), conversion_policy=">0")

      @on(trigger_cv, edge="rising")
      def hold_value(self, value, ctx):
        return self.input

The control layer uses a small WebSocket protocol that the react-based web UI uses to control and introspect sessions. A WebSocket-bus neuron lets external application auto-register to it to send/receive signals: another neuron in the network can serve signals captured from any source. They're useful to distribute computation loads on different machines.
# What have I learned so far
A simple threading model can be powerful in a MIDI/music context:
* you can stop/resume a thread, stopping a part of the processing chain seamlessly;
* overflown neurons can mitigate the pressure without impacting the whole session;
* if a thread crashes, it is paused to give you the ability to debug the instance, and resume it;
* simple websockets have an acceptable throughput.
I was expecting a system entirely based on Python threads to be really ineffective, but it's surprisingly reasonable. Empirically I see ~1-2 % CPU per thread. A 20 threads classical session (~45 patches) uses roughly 21% CPU and 45MB RAM on CPython 3.13 GIL. CPython 3.14 no-GIL shows similar CPU but ~65MB RAM. Feedback loops raise usage (~38 %). Interestingly, on CPython 3.13 the load spreads across multiple cores, I suppose that the threads are sleeping enough to release often the GIL.
# Try it!
You can grab a precompiled PyInstaller built binary in the latest github actions artifacts. Doc is linked in the README, and deep-dive posts are available here: https://dr-schlange.github.io/nallely-midi/posts.
# I would love feedback
* What could be improved to make it easier to get familiar with?
* Are there blind spots or design choices that could be problematic long-term?
* Although it's MIDI-oriented, the system is really signal-agnostic, any idea for non-audio use-case? (e.g. visuals, etc)

value: Show HN: Nallely a modular reactive Python framework for custom MIDI instruments

author: drschlange


value: sumit-paul

value: Show HN: GitGallery – A privacy-first photo vault that uses GitHub as storage

author: sumit-paul


value: Kholin

value: Show HN: Self-hosted community platform with live chat and SEO friendly

author: Kholin


value: Show HN: First Principles articles teaching a variety of languages


value: anonfunction

value: Show HN: macOS menu bar app that monitors your Ethernet connection status

author: anonfunction


value: smith-kyle

value: Show HN: I built a CLI tool to automatically break up large PRs

author: smith-kyle


value:
We built Tangent, a stream-processing engine with WASM at its core. In our benchmarks, end-to-end ingestion and transformations perform at native speed, with some workloads even running faster.
Hi HN, we’d like to share our open-source stream processing engine written in Rust, where WASM transformations/enrichments are first-class.
There have been several earlier attempts to bring WebAssembly into the streaming world (Arroyo, Vector, etc.) that faced toolchain or runtime-maturity issues. We felt now is the right time: thanks to recent performance improvements by the wasmtime team, we see ~230 MiB/s throughput ingesting from a socket and passing to a Go-WASM transform[1] on a 16 core machine. The same workload runs with slightly lower throughput in native Go.
WASM is not just a novel technology we wanted to play with; we have two core motivations:
1. We’ve been collaborating with the OCSF team, and discovered that sharing vendor->OCSF mappers is a big hurdle (vendor schema drift + OCSF updates). With WASM, we don’t need to agree on a DSL before we can share transformations.
2. LLMs are much better at writing code (Go, Python, etc.) than domain-specific languages. We wanted a stream processor where you can write plugins, test, and benchmark easily and locally. With Tangent we rewrote all the mappers in the OCSF examples repo in about an hour[2]
We’d love to hear your feedback!
[1] https://github.com/telophasehq/tangent/blob/main/examples/go...
[2] https://github.com/ocsf/examples

value: Show HN: Tangent – Open‑source stream processor with native‑speed WASM plugins


value: Sean-Der

value: Show HN: Pion/rtwatch – Watch video in sync with friends, pause/seek on back end

author: Sean-Der


value: johnrpenner

value: Mack the Moose (a playful twist on 'Mack the Knife') is a modern millenial descendent of the original Talking Moose for the Macintosh with some Rizz

value: Show HN: Talking Moose Is Back Baby Mack the Moose

author: johnrpenner


value:
A couple things motivated me to build NameKnow.
I got tired of seeing people building projects with names that create distrust with their customers.
Now that llms can fart out features, I've been thinking about how you can build something that will last. A unique distribution channel or domain are what I came up with. I like names, so a domain name marketplace was a natural fit for me.
Thanks in advance for your feedback.

value: Show HN: Curated Domain Name Marketplace


value: uaghazade

value: as an solo developer, i kept wasting time searching for cheaper or self-hosted alternatives to overpriced tools. so i built alterbase.co, a community-driven directory of handpicked indie-friendly software alternatives.

value: Show HN: Just launched AlterBase. Find cheap alternatives to expensive tools

author: uaghazade


value: Show HN: Nomad – Real-time collaborative editing in Neovim


value: dempedempe

value:
Mental arithmetic has been a hobby of mine for a while.  It's fun and good exercise for your brain.
When I switched to iOS, I couldn’t find a decent app. Most had ads, sign-ups, excessive gamification, or mandatory subscriptions, and none were customizable enough. So I built my own.
Athena Math lets you
- Practice operations not normally found in mental math apps: modulo, square roots, percents, GCD and LCM
- Tailor each session: set your time or problem limits, choose digit ranges (1–5), mix digit lengths (e.g. 55 + 436), and select any combination of operations you like.
- A detailed stats screen that shows the time you spent on problems, problems per day, percent correct, etc.  All graphs are filterable.
- A history screen that shows all your sessions.
- You can import and export your history for offline analysis or to transfer
- Offline tutorials are included for all operations
- Lastly, you can use it immediately. There are no accounts.
So far, it's received a positive response from the mental math community. It's an incredible feeling to have people actually value my work enough to pay for it. (This was my first app).
I've had a lot of fun building Athena math and using it myself. Practicing obscure operations like GCD, LCM and square roots has taught me to see patterns in numbers that I didn't see before. Overall, it's improved my number sense.
It's built in React Native + Expo/EAS. I use Fastlane to manage app store metadata (and store in version control), and it's using a serverless AWS backend for payment verification. History is stored locally in an SQLite database.
It's free to use! You're limited to 12 sessions daily, but if you wanna keep using for free, you can simply delete your daily sessions. You loose history and stats, but it's an option. You can also just set the time limit to infinity.
I know mental math is not the sexiest market, but I'd love feedback from the HN community -- on the app, the UX, or the technical setup. Any ideas for improvement? What are your thoughts?
Thanks for reading and happy hacking!

value: Show HN: I built a highly customizable mental arithmetic trainer for iOS

author: dempedempe


value:
Just an experimental little npm library for creating a quick feedback loop when writing code.
The basic idea is that it runs a quick check on any code when a file is written to, and when code is committed.
I expect there are quite a few bugs etc but it has been running smoothly enough for me so far.
https://github.com/whatever555/ollama-watcher

value: Show HN: Ollama-watcher – On the fly code reviews using Ollama


value: arjunven

value:
We're building Merlin to speed up electrical component selection, starting with ceramic capacitors. Overview video: https://youtu.be/FrGrivAKhnc
The problem:
We hated the tedious work of choosing components: copying specs into spreadsheets, taking screenshots from multiple datasheets, and cross-referencing parameters across manufacturers.
What we built:
- A comparison tool that displays all relevant electrical/mechanical specs along with the performance curves in a single view
- An alternates tool that identifies equivalent parts based on a reference component
We think this helps because:
Instead of juggling multiple browser tabs and Excel sheets, you can quickly verify if a part meets your requirements and find alternates when your current part is out of stock or EOL. We found it also helps during the design phase to readily compare specs and find better parts.
Try it out at www.get-merlin.com - we'd love your feedback, especially:
- What information are we missing that you need?
- What component types would be most valuable?
- How does your team currently handle component selection?
You can use the comparison tool for free, and we have a 14 day trial of the alternates tool available now.

value: Show HN: Make Electrical Component Selection Suck Less

author: arjunven


value: brandon-bennett

value:
Self-hosted app store for AI agents. Federated discovery, container isolation, run on your infrastructure.
The problem: most organizations either build every agent in-house or send their data to third-party servers.
You wouldn't build your own email client or maps app - you'd download one. AI agents should work the same way. I spent a year building the infrastructure to make that possible: discover agents built by others, run them on your infrastructure (private cloud, on-premises, or local) without sending your data to third-party servers.
Key architecture:
- Federated Git-based index (fork-based ownership, no gatekeepers)
- Container isolation + egress proxy (you configure which URLs agents can access)
- Credential injection (API keys configured on host, not in agent images)
- Model abstraction (works with Ollama local, cloud APIs, or hybrid)
- Hash-chained audit logs
The platform works. The agent index is mostly empty, but someone has to build the rails so the trains can run.
Apache-2.0 open source. Pre-release but functional.
GitHub: https://github.com/agentsystems/agentsystems
Docs: https://docs.agentsystems.ai
Looking for:
- Agent builders to publish to the index
- Security researchers to review the architecture
- Organizations that need self-hosted AI infrastructure

value: Show HN: Federated app store for self-hosted AI agents (Apache-2.0)

author: brandon-bennett


value: AlexanderZ

value: Show HN: Single Day – lower your anxiety and stop procrastinating

author: AlexanderZ


value: deepsdev

value: Show HN: AI Chat for Your Documentation

author: deepsdev

title: Show HN: AI Chat for Your Documentation


value: With some window management magic, we can show stuff to OBS that the client can't see. We're exploring the design space to see what sticks!

value: Show HN: A horror game where Chat sees things you can't


value: buremba

value:
Hey HN! I usually create helper scripts for Claude to reuse and organize the file structure, allowing me to run multiple agents on the same codebase. I had around 150 conversations for a project, so I wanted to see if I could automate the process of analyzing my conversation history to see if I could build something valuable from it.
Apparently, conversation history is gold for spotting repetitive tool calls. I deleted a helper script that I had recently created from the repository and the conversation history, and Claude suggested that I make them when I ask it to suggest helper scripts.
I had to perform data cleaning & enrichment on the conversation history to make it worthwhile for CC, so I've turned it into an open-source plugin anybody can use. It's handy for both repetitive workflows and coding use-cases.
The script adds a `/agent-trace-ops:plan` slash command, and all data is processed locally via your Claude Code. Let me know if it's useful!

value: Show HN: Batch Claude Code tool calls into one using chat history to save tokens

author: buremba


value: NervousIbexDev

value:
Hey everyone!
I just released my new Android idle game called Idle Fishing.
You can catch fish, upgrade your boat, and enjoy a relaxing experience by the sea.
I made all the pixel art myself and built everything from scratch using LibGDX.
Would love to hear your thoughts and feedback — especially from other indie devs!
https://play.google.com/store/apps/details?id=com.nervousibe...
Thanks for checking it out

value: Show HN: Idle Fishing Simulator – A relaxing idle game about fishing (Android)

author: NervousIbexDev


value: abilafredkb

value:
Two months ago, I was doom-scrolling through news about global division and realized: we're more "connected" than ever, yet lonelier than we've ever been. Every friendship app is just Tinder mechanics applied to platonic relationships. Endless swiping. Dead conversations. No commitment.
So I built Eintercon with one controversial feature: you get exactly 48 hours to chat with a match, then you both decide—continue or move on. No ghosting allowed.
Why 48 hours?
It's personal. Five years ago, I hesitated for 48 hours before messaging someone on Facebook who became my mentor and changed my life trajectory. That window taught me something: constraints create commitment. Urgency forces presence.
Why international-only (for free users)?
Because you can't hate someone whose story you know. I matched a user from Kenya with someone from South Korea over their shared obsession with obscure sci-fi. They've been talking for three weeks now. That wouldn't happen if we let everyone stay in their local bubble.
The controversial parts:
Forced decisions - After 48 hours, both people vote. If either says no, it's over. People tell me this is "too harsh." I think ghosting is harsher.
No local connections for free users - You can only match internationally unless you pay. People say I'm "limiting" the app. I say I'm forcing cross-cultural connection.
Interest-based only - No location data, no "people nearby," no "mutual friends." Just: do you both love analog photography? Then talk.
Current status:
200+ users across 30+ countries
Built in one month
Zero marketing budget
40% of matches result in continued friendships
Users report "first real friend in years"
The big question I'm grappling with:
Am I engineering connection or just adding more friction? Does urgency create genuine relationships, or does it just gamify them differently?
Some users love the pressure. Others hate it. One person told me the 48-hour countdown gave them anxiety. Another said it saved them from months of dead-end pen-palling.
I'm genuinely unsure if this is brilliant or broken.
What I'd love feedback on:
Is the 48-hour window too aggressive? Too short? (I've considered 72 hours, but that feels too safe)
Am I wrong to force international-only for free users? (most apps instead let users pay for international connections)
How do you prevent this from becoming another performative "networking" tool?
Should friendship apps even exist, or am I solving a problem technology created?
The uncomfortable truth: I built this because I'm lonely too.Maybe I'm building this for myself. Maybe that's okay.
What do you think? Am I onto something or just creating another digital hamster wheel?

value: Show HN: Eintercon – I'm forcing people to decide on friendships in 48 hours

author: abilafredkb


value: OliverGilan

value:
Hey HN! We’re Oliver Gilan & Ben Warren and today we’re launching Mesa (https://mesa.dev) into public beta to help large engineering teams review code more effectively.
There are plenty of code review agents that exist but we found that they fall short in a number of ways. They don’t…
- Let you tailor the reviews with enough fidelity
- Give you control over the models used. If a new foundation model is released I might want to try it!
- Align the costs effectively
Mesa solves these problems with a multi-agent architecture where you define custom review agents that specialize in reviewing certain dimensions of your codebase.  This allows you to finely control the review quality and receive reviews that are aware of specific dependencies, business logic, a specific domain in your codebase, or anything else you care about.
You can control the model a specialist uses which is great for trying newly released models but also for controlling costs. When a change is made to our database schema, we have a specialist agent that reviews it and uses the most expensive, smartest, model it can while our frontend agent uses a faster, cheaper agent.
Control over models and the fact that we only charge you for the tokens you use, at cost, aligns our cost structure and gives teams control that they do not get with other agents.
We’ve found code review to be a subtly big problem for teams trying to improve development velocity. It’s the primary point of contact for managing the changes to the living system of your codebase and mistakes are costly.
Missed bugs that make it to production can cause downtime, lost revenue, loss of trust, security breaches, compliance breaches, etc. Engineers spend hundreds of expensive man-hours that they do not enjoy reviewing code and still there’s too many mistakes being made.
We do not believe you can remove humans from the loop of reviews entirely but we can dramatically shift the amount of work done on an average code review and eliminate the need for human reviews altogether on a large subset of PRs. This sort of automation will lead to faster teams and more reliable codebases over time.
We are now in public beta and there’s a generous free tier (~100k lines reviewed free per month) available to all. Give it a spin and let us know what you think!
Oliver & Ben

value: Show HN: Multi-Agent Code Review

author: OliverGilan

title: Show HN: Multi-Agent Code Review


value: jobsandai

value:
Built a tool that analyzes your specific role/skills against AI automation trends and suggests realistic career pivots.
Takes a 2-min questionnaire, runs it through structured LLM prompts with validation logic, outputs a PDF with your automation risk score, transferable skills breakdown, and adjacent roles that make sense for your situation.
Free, no signup. Main technical challenge was balancing personalization depth vs speed - needed fast enough that people finish it.
Try it: https://jobsandai.com
Feedback welcome, especially on recommendation quality. Still figuring out if this is actually useful or just feels useful.

value: Show HN: JobsAndAI – Personalized career risk analysis for AI disruption

author: jobsandai


value: sriharis

value: Show HN: Agentic semantic search, but with GitHub APIs

author: sriharis


value: dhdaadhd

value:
Hey guys!
I just launched a website for sharing, exploring and comparing ZSA layouts — Keyderboard.
It was born from my struggle onboarding to the ZSA Voyager, discovering Oryx's features, and escaping local optima in my layout. My goal with Keyderboard: surface the best layouts for every application, language, and use-case.
I encourage you to check it out and, if willing, submit your current layout! The more the merrier.
Check it out! https://www.keyderboard.com/
Feedback welcome. I'm actively developing the site :)

value: Show HN: A better ZSA keyboard layout explorer

author: dhdaadhd


value: gitprolinux

value: My way of giving back to the programming people.  Simple tips, I find effective.

value: Show HN: A simple programming centric WordPress: TopCoders.Cloud

author: gitprolinux


value: fcpguru

value:
I was at a networking event. About 40 people at a bar/restaurant in Culver City and it was great! Lots of interesting people. Great conversations but when it was over, I had no way to contact any of these people. So I started writing this bluetooth app. Using CBCentralManager on ios and BluetoothManager on android. Each phone broadcasts as a peripheral but also connects as central. Rooms full of phones running the app gossip.
Think of the term "peripheral" as server and "central" as client. Yes there are differences in bluetooth and reasons for those terms, but my life got much easier thinking: client server. So in a room with just two phones, which one is which? It can't be a coin toss. If 50% of the time both phones act as the server and neither client, bad. Or if both phones act as clients, bad. So how do you break the tie? You start up your server AND act as a client looking for servers. Just be careful not to connect to yourself!
With bluetooth your server advertises and when you connect it tells you what characteristics it has. Think of characteristics as "endpoints". They are not the same as http endpoints at all but again my life got easier thinking of them like this. Our app has two characteristics PROFILE_CHAR and PHOTO_CHAR and step one is a client hits PROFILE_CHAR and gets back json with device_id, first_name, photo_hash, instagram. It could be binary or Protocol Buffers but I went with json.
So with my 200 OK from PROFILE_CHAR I look at the photo_hash which is a 256 sha from the binary data of the user photo. If I have this file cached, I'm good and disconnect. If not I hit PHOTO_CHAR and get the image data in chunks and save as hash.jpg locally. Then disconnect. After I disconnect I place that bluetooth server id on a cooldown list. I have other phones in the room to connect with! All this time I'm also acting as a server. Sometimes when I'm busy being a client getting a photo I'll pause my server actions. It depends on ios vs android. There is lots of complexity in the BLE stack. This loop of find server, connect, get info, disconnect, repeat works great. But there are limits and GATT errors and queue buffers and MTU (max transmission unit) issues that can make two phones next to each other take a while to find each other.
So I made github.com/andrewarrow/auraphone-blue which is a BLE stack simulator written in golang. If you look at the wire package you'll see a BLE implementation using the file system and domain sockets to mock the radio. The swift package and kotlin package should look familiar to anyone who has worked on ios or android BLE. My plan was to run many mock phones and test all the weird BLE differences between ios and android. It did not work. The only thing this golang repo did was help me understand how bluetooth works. This BLE stack I made doesn't fix ios and android bugs, it introduces its own subtle golang filesystem ble bugs!
In the end nothing fixed bugs better than running two real ios phones and two real android phones and having them write very thorough logs PLUS ble specific json files showing exactly what each operation was doing and what info it got back. I ended up writing logic to zip up the entire local directory of the phone with all these files and logs and doing an HTTP POST to my local mac just to get all the data off all 4 phones quickly after each run.
But now after your conversation is done and you move around the room, you have a record of who that person was. The list is sorted by last updated_at desc so whoever you are near will be at the top. Great for when you met someone earlier and forget their name. Now you just look down at your auraphone app and say oh hey jessie!
ios app store:
https://apps.apple.com/us/app/auraphone/id6752836343
or download the android apk:
https://andrewarrow.dev/auraphone/
Looking to try it now in a room full of people!

value: Show HN: A simple app to collect people's info at events (bluetooth)

author: fcpguru


value: perhapsAnLLM

value:
If you're anything like me (just a tad bit obsessed with fantasy sports), you've probably found yourself doing mock drafts or watching fantasy sports content in your spare time. Lately, I've been watching a lot of NBA 2K fantasy draft videos - I haven't played the games in years, but I had the itch to get back in the action.
That's why I built DraftDawg, a simple website to simulate NBA 2K fantasy drafts! You can choose from up-to-date current or all-time rosters, and optionally run some fun challenges to spice up your draft. My favorites are *Alphabet Soup* (draft a player whose first or last name starts with a randomly-assigned alphabet) and *Attribute Roulette* (draft a player whose attributes meet a randomly-specified restriction).
I'd love some feedback from fellow sports-obsessed! Let me know what features, draft challenges, or improvements you'd want to see.
Website: https://draftdawg.app/

value: Show HN: I Built an NBA Fantasy Draft Simulator

author: perhapsAnLLM


value: LeonelRuiz

value:
I built TestiWall, a simple tool to collect and display testimonials (or “Walls of Love”) on your website.
I made it because I needed an easy, no-code way to show real feedback from users on my own projects, but all the existing tools were either too complex or expensive.
With TestiWall, you can:
Create a testimonial wall in under a minute
Embed it on sites built with WordPress, Wix, Shopify, custom code or any platform.
Customize the design without writing code
Here’s a short demo video https://trytestiwall.com
I’d love to hear your feedback — especially about the UX or ideas for improvement.

value: Show HN: A simple tool for collecting and displaying testimonials in 1 minute

author: LeonelRuiz


value: CLCKKKKK

value:
Hi HN, I'm Kevin, co-founder of PivotHire AI.
We're building a platform to fix what we see as a core problem with freelance sites: clients spend more time managing freelancers than doing their own work.
Our approach is an "AI-Managed" abstraction layer. The key architectural decision is that clients and developers do not interact directly. Also, most talents are senior software developers from China that are cheap but high-value.
It's an event-driven workflow:
- A client submits a project goal in natural language.
- Our AI PM (built using LLMs) deconstructs the goal into concrete technical tasks, milestones, and deliverables.
- These tasks are routed to our vetted developer pool.
- The AI PM manages the entire lifecycle: progress tracking, check-ins, and validating deliverables before packaging the final product for the client.
The main technical hurdle we're tackling now is agent reliability. Getting it to correctly parse complex project info, monitor progress accurately, and trigger notifications via a VM-based system is non-trivial. The prompt engineering required for this kind of long-running, stateful project management is where most of our effort is.
Our stack: Next.js, Sass, shadcn/ui, and gpt-4.1-nano for the agent.
We're in the very early stages and would love to get your feedback on the core concept and our technical approach.

value: Show HN: PivotHire – Project delivery service as easy as e-commerce platforms

author: CLCKKKKK


value: VatroslavM

value:
I built a small Windows app that automatically skips songs you’ve recently listened to on Spotify, using your Last.fm scrobbles as memory.
It runs quietly in the system tray and checks your current Spotify track every few minutes. If the song was played within the last n days (default 60), it sends a “skip” command via Spotify API.
It’s open-source (MIT licensed) and configurable through a simple config.ini file. You can adjust how many days back to check, how often it polls, and set your Spotify and Last.fm API keys.
Repo: https://github.com/Vatroslav/spotify-auto-skipper
Would love feedback — especially from anyone who uses Spotify and Last.fm heavily or wants to automate their listening habits.

value: Show HN: Spotify Auto Skipper – automatically skips songs you've heard recently

author: VatroslavM


value: daftpixie

value:
I'm building ReadMyMRI to solve a problem I kept running into: getting medical imaging data (DICOM files) ready for machine learning without violating HIPAA or losing critical context.
What it does:
ReadMyMRI is a preprocessing pipeline that takes raw DICOM medical images (MRIs, CTs, etc.) and:
Strips all Protected Health Information (PHI) automatically while preserving DICOM metadata integrity
Compresses images to manageable sizes without destroying diagnostic quality
Links deidentified scans to user-provided clinical context (symptoms, demographics, outcomes)
Uses multi-model AI consensus analysis for both consumer facing 2nd opinions and clinical decision making support at bedside
Outputs everything into a single dataframe ready for ML training using Daft (Eventual's distributed dataframe library)
Technical approach:
Built on pydicom for DICOM manipulation
Uses Pillow/OpenCV for quality-preserving compression
Daft integration for distributed processing of large medical imaging datasets
Frontier models for multi model analysis (still debating this)
What I'm looking for:
Feedback from anyone working with medical imaging ML
Edge cases I haven't thought about
Whether the Daft integration actually makes sense for your use case or if plain pandas would be better
HIPAA/privacy concerns I am not thinking about
Happy to answer questions about the architecture, HIPAA considerations, or why medical imaging data is such a pain to work with.

value: Show HN: ReadMyMRI DICOM native preprocessor with multi model consensus/ML pipes

author: daftpixie


value: logannyeMD

value: This is an external-memory ETL engine that enforces hard memory bounds (as opposed to systems that can only try to stay within limits). It's the result of playing around with a recent idea from complexity theory, tinkering to find practical applications of where efficient time-space simulation could be useful.<p>It enforces a strict memory cap via RAII tracking and scheduling, so you can process arbitrarily large datasets with a fixed, small memory footprint. Operators automatically spill to disk when needed. Might be helpful for serverless and edge environments where you need predictable resource usage.

value: Show HN: An ETL engine with hard memory guarantees

author: logannyeMD


value:
Hey HN, we’re Iyan and Datta, founders of Barcable.
Barcable connects to your backend (HTTP, gRPC, GraphQL) and uses autonomous agents to generate and run load tests directly inside your CI/CD. No configs, no scripts. It scans your repo, understands your API routes, and builds real test scenarios that hit your endpoints with realistic payloads.
Docs: https://www.barcable.dev/documentation
We built this out of frustration. Every team we’ve worked with ran into the same issue: reliability testing never kept up with development speed. Pipelines deploy faster than anyone can validate performance. Most “load tests” are brittle JMeter relics or one-off scripts that rot after the first refactor.
Barcable is our attempt to automate that. It:
- Parses your OpenAPI spec or code to discover endpoints automatically
- Generates realistic load tests from PR diffs (no manual scripting)
- Spins up isolated Cloud Run jobs to execute at scale
- Reports latency, throughput, and error breakdowns directly in your dashboard
- Hooks into your CI so tests run autonomously before deploys
Each agent handles a part of the process—discovery, generation, execution, analysis—so testing evolves with your codebase rather than fighting against it.
Right now it works best with Dockerized repos. You can onboard from GitHub, explore endpoints, generate tests, run them, and see metrics in a unified dashboard.
It’s still a work in progress. We’ll create accounts manually and share credentials with anyone interested in trying it out. We’re keeping access limited for now because of Cloud Run costs.
We’re not trying to replace performance engineers, just make it easier for teams to catch regressions and incidents before production without the setup tax.
Would love feedback from anyone who’s been burned by flaky load testing pipelines or has solved reliability differently. We’re especially curious about gRPC edge cases and complex auth setups.
HN has always been a huge source of inspiration for us, and we’d love to hear how you’d test it, break it, or make it better.
— Iyan & Datta
 https://www.barcable.dev

value: Show HN: Barcable – We Built Agents That Automatically Load Test Your Back End


value:
It's time for a better Venmo/PayPal...
One that is globally accessible, makes you money and takes a cut of the profit instead of screwing you with fees and bad conversion rates
I made the iOS + web app and I'm handing it to you
Send USDC via email
Btwn Friends is an open-sourced PayPal/Venmo alternative that let's you send stablecoins to anyone's email without them being on the app, having a wallet or knowing about crypto.
Here's how it works
Every P2P payment app makes you create an account, save 12 words, link to a wallet app, KYC, transfer gas tokens...
It's intimidating and too much work
Your friend just wants their $20 back. They don't care about "decentralization"
Here you sign in with your email and a one time use password (OTP)
That's it.
You just logged into your wallet or created one. no wallet app, chrome extension, seed phrase, or crypto knowledge.
Your wallet is created automatically by Coinbase Developer Platfrom
To send money, you just need an email address.
Not a wallet address or an ENS name. Just an email.
Enter: friend@example.com → $25 USDC → Send
That's the entire flow.
The recipient gets an email: "John sent you $25"
They click the link → Sign in with email → Funds appear.
They don't need to:
- Set up a wallet
- Have ETH for gas
- Know what a blockchain is
- Copy/paste addresses
If your friend is on the app → money goes straight to them
If they're not → money goes into an escrow
When they sign in with email & OTP, they prove they own that email.
Escrow releases funds automatically. They see their balance before the dashboard loads.
You can build onchain apps without forcing users to "learn crypto"
Between Friends is built on Base (Eth L2) using a basic escrow smart contract and is powered by Coinbase Developer Platfrom's Embedded Wallets (smart accounts) and Paymaster
I've done most of the job for you and left notes on what's left.
Coinbase Developer Platfrom's Embedded Wallets already give you ~%4 rewards on balance out the box
You can make more for yourself & your users leveraging onchain tools like
@MorphoLabs, @MoonwellDeFi, @superformxyz...
→ Web app:
https://btwnfriends.com
→ iOS testflight:
https://testflight.apple.com/join/aZCPAjwZ
→ Repo:
https://github.com/Must-be-Ash/btwnfriends

value: Show HN: Send USDC via Email

title: Show HN: Send USDC via Email


value: maddiedreese

value:
I bought my first Raspberry Pi a little while ago. I grew up with my Grandpa building cool projects on the Pi. I was always interested in building my own, but never got the chance to.
Around a week ago, I saw two projects on Twitter. Once was a receipt printer that could print out daily tasks, and the other was a light display that people could send their own designs to.
Inspired by these, I decided to build my first Raspberry Pi project: Message Maddie. It’s a Raspberry Pi 4B connected to a generic thermal receipt printer. Built with Cursor, a Convex database, and frontend hosted on Netlify.
Basically, you go to the website: https://message-maddie.netlify.app, enter whatever message you’d like to send, and it’ll print out instantly on my printer.
I posted it on Reddit and have received over 1300 messages so far, from what seems like every corner of the world. It’s absolutely incredible to me what people have chosen to share: everything from a “Hello!” to their deepest hopes and dreams. I started this as a fun little project, but it’s become so much bigger than that. I’ve never felt so connected to the world.
I also decided to open source the project if anyone would like to build their own! I’ve had people tell me they’re going to build one to communicate with their small kids while they’re going through a divorce, or to send messages to their partners while they’re doing long-distance. This is my first open source project, so please reach out with any issues! https://github.com/maddiedreese/ticket-printer-os
Hope to see a message from you come through on my printer soon!

value: Show HN: Send a message to my printer from anywhere in the world

author: maddiedreese


value: jeffsevens

value: Show HN: AI-powered sponsorship platform (proposals, research, mockups)

author: jeffsevens


value: superfa

value: Show HN: Free Games Pit – Play Free Online Games Instantly – 1500 Browser Games

author: superfa


value: theryangeary

value: Last week while sitting on the subway I noticed the displays in the newer (R211 maybe but I don't really know my trains models) display what are essentially captions of the overhead announcements. As it was flashing "ALCOHOL" on the screen I started pondering what else one could display on these screens, just for fun. I ended up creating a generator and now I hope you'll enjoy it, and maybe leave a message in the gallery a la guestbooks of the early internet.

value: Show HN: Generate custom MTA Subway displays

author: theryangeary


value: martinoV

value: Show HN: Google Notebook LM for your team

author: martinoV


value: lakshmananm

value: Show HN: Anonymous Peer to Peer Therapy

author: lakshmananm

title: Show HN: Anonymous Peer to Peer Therapy


value: sasasavic

value:
SasaSavic.ca recently launched a public cryptographic timestamping service designed to remain verifiable even in a post-quantum world.
The platform uses SasaSavic Quantum Shield™, a dual-signature protocol combining classical and post-quantum security.
Each submitted SHA-256 hash is:
• Dual-signed with ECDSA P-256 and ML-DSA-65 (per NIST FIPS 204)
• Anchored to the Bitcoin blockchain via OpenTimestamps
• Recorded in a public, verifiable daily ledger
API (beta, no auth required):
https://sasasavic.ca/beta-api/
Example curl request:
curl -X POST https://sasasavic.ca/api/v1/beta/timestamp
 -H "Content-Type: application/json" -d '{"hash":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"}'
Verification and ledgers:
https://sasasavic.ca/verify
https://sasasavic.ca/ledgers/
The goal is to make cryptographic proofs quantum-resistant and accessible, while preserving user privacy — only the hash ever leaves the client side.
Feedback from developers, auditors, and researchers on PQC integration and verification speed is welcome.
More details and documentation:
https://sasasavic.ca/quantum-shield/
– The SasaSavic.ca Team

value: Show HN: Free Quantum-Resistant Timestamping API (Dual-Signature and Bitcoin)

author: sasasavic


value: libiny

value:
Title: Show HN: Notifikai — Set and get reminders through simple text messages
Body:
Hey everyone,
I built Notifikai because I kept forgetting small daily tasks when I was away from my phone or offline. Most reminder apps need logins, notifications, or constant internet—so I made something simpler.
With Notifikai, you just send a text like:
“Remind me to take my vitamins at 9am tomorrow.”
Then at 9am, you’ll get a text that says:
“Take your vitamins.”
No app, no setup, no logins—just plain SMS. You can create one-time or recurring reminders, manage them by replying to messages, and it all works anywhere a text message does.
I’d love feedback on what features would make this even more useful (for example: group reminders, daily summaries, or integrations).
Try it out here → https://notifikai.com
Thanks,
Luke

value: Show HN: Notifikai – Set and get reminders through simple text messages

author: libiny


value: funcin

value:
Hi Hacker Friends,
I'm excited to share my new project, ImagineToVideo. My goal was to build an AI video generation tool that’s powerful enough for pros but simple enough for everyone.
We're focused on making video creation straightforward and support three main modes:
● Text-to-Video
● Image-to-Video
● Template-driven Video
To balance quality and cost, we've integrated a range of models. For high-end, cinematic results, we support top-tier models like VEO 3.1 and Sora 2.
At the same time, we know those models can be expensive. To keep it accessible and reliable for more casual or high-volume use, we also offer the Kling model, which provides a great balance of quality and affordability.
Our core focus is:
Simplicity: A clean UI with no steep learning curve.
Model Flexibility: Choose the right model for your specific need and budget.
Versatility: Built for everyone from solo creators and marketers to e-commerce owners.
This is a new launch, and I'd be genuinely grateful for any feedback, bug reports, or feature ideas from the HN community. Let me know what you think!

value: Show HN: ImagineToVideo –An accessible AI video generator withVEO, Sora2

author: funcin


value: selenehyun

value:
Hi HN,
I built Tenant Operator - a minimal Kubernetes Operator for native, declarative multi-tenancy.
It lets you define tenants as CRDs and automatically provisions:
* Namespaces with isolated RBAC and network policies
* ResourceQuota and LimitRange
* Full tenant lifecycle (create/update/delete)
One unique part: it can provision tenants directly from your database — a new DB row instantly becomes a `Tenant` CR and triggers namespace/RBAC setup.
This makes it easy to build SaaS-style onboarding like Atlassian Cloud or Slack, where a tenant is created immediately after signup (or by a customer manager in real time).
I first built an early version ~2 years ago, running over 150 tenants in production.
This new design generalizes those lessons into a simpler, more universal interface.
Multi-tenancy isn’t a common need, so real-world feedback is invaluable.
If you spot design flaws, anti-patterns, or confusing docs - please let me know. Even small input helps make it stronger.
Repo: https://github.com/kubernetes-tenants/tenant-operator
License: Apache 2.0

value: Show HN: Tenant Operator – Provision Kubernetes Tenants Directly from Your DB

author: selenehyun


value: Online tool that gives the user the power to place sprinklers on a simulated lawn and see stats about their coverage, efficiency, missing spots. sprinklers and layout can be set at different sizes for personalized scnearios

value: Show HN: Smart lawn Sprinkler layout designer directly in the web


value: Show HN: Scrape user-interface AI responses at scale


value: MaxDevv

value:
I built a Python wrapper for the OpenAI SDK that compresses text into images before sending to vision models. Basically for large contexts, images can be more token-efficient than raw text.
The approach builds on DeepSeek's OCR compression research. Through 90+ experiments using an "Optical Needle in a Haystack" evaluation framework, I systematically optimized compression parameters across fonts, sizes, and resolutions.
The wrapper is a drop-in replacement for the OpenAI client - just add "compressed": True to messages containing bulk content. I recommend keeping instructions as plain text and only compressing documents, chat history, or codebases.
Links: Wrapper library: https://github.com/MaxDevv/Un-LOCC-Wrapper, Research & benchmarks: https://github.com/MaxDevv/Un-LOCC

value: Show HN: Un-LOCC Reduce LLM API costs by compressing text into images

author: MaxDevv


value:
We’re building an open-source language layer on top of Go, designed specifically for COBOL-style workloads:
 Native decimal arithmetic (COBOL-accurate)
 Record structures and copybook compatibility
 Batch jobs and transactional orchestration as
 first-class constructs
 Sequential / indexed file I/O baked into the
 runtime
 Compiles through Go for speed, concurrency, and
 cloud deployability
Think of it as Kotlin for COBOL, or “COBOL on Go” familiar to mainframe engineers, powerful for modern developers.<p>Test Results so far:
 NIST COBOL-85 validation: 77.61% overall (305/393 tests)
 NC (Core COBOL): 97.89% (93/95)
 SM (Statements): 100% (13/13)
 RL (Relative I/O): 100% (26/26)
 IF (Intrinsic Functions): 100% (45/45)
 IC (CALL): 96% (24/25)
 Compliance tests: 100% passing
 Acceptance tests: 100% passing

value: Show HN: A new language for COBOL workloads, built on Go


value: DylanLong

value: Show HN: X-Pilot – Focused on Engagement. Built for Twitter Growth

author: DylanLong


value: lukaslukas

value:
Personally, I hate having to edit slides in Google Slides or PowerPoint because everything can be moved! After every simple text edits, I have to change the position of every text element, and so on. Awesome functionality is missing from HTML and CSS: auto-aligning.
The idea of converting Markdown to slides is not new. There are lots of tools that do it well.
Unfortunately, libraries like Reveal.js or Marp are too geeky and developer-focused for something as simple as creating quick slides.
That's where Slidepicker.com comes in.
Compared to tools like Marp or Deckset, Slidepicker focuses on creating slides that look really good. It's not just about fast and easy creation, but also about achieving great readability of the result.
We’ve just released a new version of SlidePicker, a simple web app that converts Markdown files into presentation slides. It’s designed for developers, writers and tech speakers who prefer text-based workflows, but who also want slides that are clean, ready to share and attractive.
The editor runs entirely in the browser and supports live preview and also includes a 'presentation mode' for talks.
We would love to hear feedback from anyone who has used Markdown-based slide tools: what are you still missing, and what is your ideal workflow for creating slides from code or documents?

value: Show HN: I got tired of PowerPoint, so I built Slidepicker

author: lukaslukas


value: Show HN: Stock Pulse

title: Show HN: Stock Pulse


value: I built DeepShot, a machine learning model that predicts NBA games using rolling statistics, historical performance, and recent momentum — all visualized in a clean, interactive web app. Unlike simple averages or betting odds, DeepShot uses Exponentially Weighted Moving Averages (EWMA) to capture recent form and momentum, highlighting the key statistical differences between teams so you can see why the model favors one side. It’s powered by Python, XGBoost, Pandas, Scikit-learn, and NiceGUI, runs locally on any OS, and relies only on free, public data from Basketball Reference. If you’re into sports analytics, machine learning, or just curious whether an algorithm can outsmart Vegas, check it out and let me know what you think: https://github.com/saccofrancesco/deepshot

value: Show HN: DeepShot – NBA game predictor with 70% accuracy using ML and stats


value: albemala

value:
Hey everyone!
I’ve been working on a small macOS app called Clarity (Color Accessibility Check). It started because I often needed to quickly check color contrast for accessibility while designing interfaces, but most tools I found were either too limited or didn’t support the color models I actually use when fine-tuning visual consistency.
Clarity lets you pick any color from your screen and view or adjust it using several perceptually uniform color spaces (LAB, LCH, and HCT), in addition to the usual RGB and HSL. Perceptually uniform spaces are useful because equal numeric changes in color values correspond more closely to how we actually see differences in color. That makes it much easier to tweak hues or lightness without unpredictable shifts, especially when you’re working toward accessible contrast ratios.
Once you pick two colors, the app shows their WCAG contrast ratio and compliance level (AA or AAA) clearly. It can also suggest alternative color pairs that meet accessibility guidelines while staying as close as possible to your original colors.
There’s a palette library to save and organize color pairs, plus import/export options for text, files, and even images, something I couldn’t find in other color accessibility tools.
Accessibility compliance is becoming increasingly important, not just ethically but legally. Both the European Accessibility Act (EAA) and the Americans with Disabilities Act (ADA) make accessible digital design a requirement for many organizations. I wanted to build something that makes it easy to stay within those guidelines without slowing down the creative process.
I’d love feedback, especially from designers or developers who work with color accessibility regularly. Are there features you think would make this kind of tool more useful?
Thanks for reading!

value: Show HN: Clarity – A macOS app for checking color accessibility, WCAG compliance

author: albemala


value: standew

value: Show HN: Fix your blurry photos in batch on Fix Blur

author: standew


value: alexpadula

value:
Hey hn, I'm excited to share that TidesDB has reached it's first major after a year of development, evolving from alpha to beta to the recent major and minor releases.
TidesDB is a fast, embeddable key-value storage engine library written in C, built on an LSM-tree architecture. It's designed as a foundational library you can embed directly into your applications - similar to LMDB or LevelDB, but with some unique features.
Some features
- Atomic, consistent, isolated (Read Committed), and durable transactions with multi-column-family support
- Non-blocking readers with serialized writers per column family using COW semantics
- Isolated key-value stores with independent configuration per column family
- Multi-threaded SSTable merging with configurable parallelism (default 4 threads)
- Snappy, LZ4, and ZSTD compression support
- Configurable bloom filters to reduce disk I/O
- Automatic key expiration via TTL
- Registerable custom key comparison functions
- Cross-platform support for Linux, macOS, and Windows (MinGW-w64 and MSVC)
- Simple C API with consistent error codes (0 = success, negative = error)
What's new and finalized v1.x?
- Bidirectional iterators with reference counting for safe concurrent access
- Background compaction
- Async flushing
- LRU file handle cache to limit system resources
- Write-ahead log with automatic crash recovery
- Sorted Binary Hash Array for fast SSTable lookups
- Configurable sync modes (NONE, BACKGROUND, FULL) for durability vs performance tradeoff
Few links for yeah
https://github.com/tidesdb/tidesdb
https://tidesdb.com
https://discord.gg/tWEmjR66cy
Thank you for checking out my post. I'm open to any questions, and I'd love to hear your thoughts.

value: Show HN: TidesDB – High-performance durable, transactional embeddable database

author: alexpadula


value: akardapolov

value:
Built a compact DI container for Java that avoids the pain points of Dagger 2's compile-time graph generation and the overhead of Spring/Guice's runtime reflection.
A key insight, suggested by Gemini and several other LLMs, is to use JDK 24's Class-File API for zero-reflection classpath scanning, and then MethodHandles for fast object instantiation. The solution is JSR-330 compliant.
Migrated a real project (Dimension-UI) from Dagger 2 in 2 days. Key improvements:
- No bytecode generation or proxying magic
- Actual testability (isolated unit tests now work)
- 19KB footprint vs 10MB+ for Spring
- Startup is instant
Links
Dimension‑DI: https://github.com/akardapolov/dimension-di
Dimension‑UI: https://github.com/akardapolov/dimension-ui
DI Containers Comparison: https://github.com/Heapy/di-comparison

value: Show HN: Lightweight Runtime DI for Java Using Class-File API and JSR-330

author: akardapolov


value: Paleontologist

value:
Been job hunting for months now and got tired of checking 10+ job boards every day just to find the same recycled "remote (but actually not)" positions.
So I built https://php-jobs.net
It's basically a scraper that pulls PHP jobs from multiple sources and tries to filter out the BS. Nothing revolutionary, but it saves me hours of daily searching.
The setup:
- Main site runs on a purchased CMS I'm hacking on (not proud of it but it works)
- Wrote custom parsers as a separate service using Swow - the coroutines make scraping way faster than my first attempt with regular curl / guzzle
- Queue workers running in Docker handle the updates
- Laravel/Beanstalkd keeping everything organized
Right now pulling in around 1k jobs - Laravel, Symfony, WordPress, the usual PHP stuff.
Fair warning: it's rough around the edges. Sometimes parsers break, sometimes duplicates slip through. Working on it between sending out resumes.
Would appreciate any feedback, especially:
- Know any good PHP job sources?
- Notice anything broken?
- Ideas for better filtering?
Building this while unemployed is... interesting. Part therapy, part desperation, part hoping it actually helps land something. If you're in the same boat, hopefully it saves you some time too.

value: Show HN: I built a PHP remote job aggregator to find work

author: Paleontologist


value: A simple but useful internal tool we made and proved to be useful for us. Hopefully it can help someone else as well.<p>Convert ONNX files to OpenVINO and/or TensorflowJS

value: Show HN: ONNX Converter

title: Show HN: ONNX Converter


value:
Every once in a while, I hear developers complain about how working with ROS2 frustrates them, or students who find the barriers to understanding ROS2 too high. Undoubtedly, ROS2 was originally designed in the lab for the prototyping phase.
However, being widely adopted has turned its design into a messy blob that is not only "thick" - and not in a good way - but also too tangled. Therefore, I came up with the design for HORUS -Hybrid Optimized Robotics Unified System.
At first, I was just experimenting to see whether building a system that respects both the versions and dependencies of low-level packages like drivers, and high-level packages like ML/robotics algorithms would be that hard - unlike in ROS2. Surprisingly, with current modern technology, we can do a lot to make this vision come true. ROS2 users are always looking to avoid "reinventing the wheel" by trying to pick whatever exists in that tangled web and sticking it into their project. This workflow was good, at least in the old days. But now we have AI and modern frameworks/packages, yet developers are still struggling to make them work with ROS2.
My vision is to create a robotics framework that is "thick" as a whole (we can't avoid this - the tools, drivers, etc. make it impossible to be slim and fit everyone's needs), but modular by choice. I mean that developers, similar to ROS2, can still integrate their packages, but in a way that won't require opening at least 10 tabs. The design makes parts swappable - it's like building with Lego blocks, but with easy integration. You don't like this IPC communication mechanism? Swap it with a different IPC framework by editing 1 configuration line, and it won't break. You don't like these environment settings or how upgrading a single package breaks everything else? HORUS solves this.
HORUS aims to provide developers an interface where they can focus on writing algorithms and logic, not on setting up their environments and solving configuration issues. HORUS is designed to be both hybrid and unified. For example:
You can run horus run app.py driver.rs, and Python and Rust will communicate with each other seamlessly, as they all use shared memory for IPC. If a package is missing, the HORUS manager detects it and auto-installs a version that fits your current dependencies.

  By design, every HORUS project can be a virtual environment if you want it to be. You can use packages already installed on your machine and link them to your project, or install new ones exclusively in your project. This solves dependency hell and the "works on my machine" problem. We also have horus env freeze, which freezes your environment and provides you an ID that other developers can use with horus env restore  <ID> - similar to requirements.txt in Python.

  I know what you're thinking: don't we already have these features elsewhere? Why not just install them and integrate them into ROS2, like virtual environments or multiple compilers? That's where the unified part of HORUS comes in. Robotics as a whole should be cohesive for the most part. Continuously splitting things apart and then piecing them back together will just create another ROS2. Therefore, by original design, the ecosystem should easily adopt new components and make them native. HORUS has a registry - a database of sorts - that aims to grow by gaining more HORUS packages. This makes future development easier by making every HORUS project part of the ecosystem.

 Given all that, a modern robotics framework should have better performance, be high-level, easily integrate with AI/ML, and be user-friendly - even for students breaking into the field of robotics. HORUS is trying to achieve all of this, but without growth in the ecosystem, HORUS would be just another forgotten project.

 You can try it out with the documentation to see the vision and goals: https://docs.horus-registry.dev/

value: Show HN: I was tired of ROS2, so I rewrote it in Rust


value:
Built https://dispatchgame.app/ for DispatchGame players tired of scattered tips—no sign-ups, just useful stuff:
Mission walkthroughs (nail tricky objectives fast).
Unit/loadout guides (optimize setups for progression).
Fresh in-game event breakdowns (updated for this week’s challenges).
Made by a fellow player—feedback on adding stats trackers or team comp tips?

value: Show HN: DispatchGame Companion – Handy Tools for the Roblox Title


value: ilovetux

value:
I built LogSieve as a small experiment: Can I build a small, completely client side application to parse and visualize logs.
It turns out the answer is Yes.
Drag and drop a .log or .txt file into the page, and it parses, filters, and visualizes entirely in your browser — no server, no upload, no dependencies. It supports text and regex filters, named-group field extraction, sorting, summary stats, and JSON/CSV export.
You can open it directly on GitHub Pages or just clone the repo and double-click it.
Source: https://github.com/notesofcliff/logsieve
Built as a "one-problem" weekend project — it’s basically "just" 900 lines of HTML, CSS, and JS.

value: Show HN: LogSieve – A Client-Side Log Viewer (No Back End, No Build Step)

author: ilovetux


value: linkshu

value:
Built https://clashroyalewordle.com/  for fellow Clash Royale fans who love Wordle-style games—100% free, no downloads:
Classic Mode: Guess 5-letter card names (6 tries, color hints) + daily/practice options.
Pixel Mode: Unblur card images with each guess (tests your card recognition).
Emoji/Description Modes: Decode emojis or text clues to find the right card.
No ads, works on mobile/desktop, and tracks your stats. Feedback on adding more modes (like card rarity filters)?

value: Show HN: Clash Royale Wordle – 4 Fun Modes to Guess Cards

author: linkshu


value: mf-skjung

value:
Hey HN,
I'm the creator of SemanticsAV. This project has been a long time coming, and I'm thrilled (and terrified) to finally share it with you.
A few years ago, I was designing ML-based malware detectors for a security firm, hitting top scores at major AV tests. I then left the industry for a while to work in CV/NLP and saw AI advancing at lightning speed.
Looking back, I was shocked that malware detection was still stuck in the past, fundamentally chained to the 1990s model of signature databases. Every vendor claims "AI-powered," but for most, it's just a thin layer on top of the same old signature game.
This isn't just a tech problem—it's an economic gate. The signature model means only those with massive data collection budgets can compete, forcing high prices. The result is that the entire Linux ecosystem, the backbone of the internet, has been stuck with ClamAV, a respectable but aging project, as its only real general-purpose open-source option for decades.
I consider this a structural failure, so I decided to build a solution from first principles.
My goal was to prove that a true end-to-end AI approach could replace signatures entirely, slash maintenance costs, and deliver top-tier performance without harvesting user data.
This is SemanticsAV:
- AI-Native, Signature-Free: We replaced the slow, expensive, and fallible work of human signature creation with a single, end-to-end AI. It learns directly from raw binary architecture to discover its own brutally effective patterns, achieving a level of speed, accuracy, and economic efficiency that human-guided systems simply cannot match.
- Free for Linux, Forever: The scanner is perpetually free for all commercial uses on Linux, requiring only attribution. To maintain top-tier performance against emerging threats, we periodically release ultra-lightweight AI models (typically <5MB per file type). These updates are downloaded on-demand via the open-source CLI, ensuring the core engine remains 100% offline during scans.
- Trust Through Verifiable Architecture: The core engine (SDK) is a closed-source binary, but it is architecturally incapable of networking. This isn't a claim you have to trust; it's a fact you can verify. Run it behind a firewall or with any network monitor, and you will see zero outbound connections from the SDK. All legitimate network activity is handled exclusively by the MIT-licensed open-source CLI, which you can audit line by line.
- Privacy by Design(Offline-First, Online-Optional): The free scanner is 100% offline by design. For deeper threat attribution, you can choose to enable our paid Cloud Intelligence service. Even then, we don't want your files. The SDK extracts a tiny (~15KB) encrypted "architectural fingerprint," and the open-source CLI then transmits it for analysis. This fingerprint is a one-way transformation; the original file is never sent and cannot be reconstructed from it. This service exists to solve the AI's black box problem by showing you the evidence behind a verdict.
Current Status & The Ask:
The platform currently supports PE and ELF files, with more formats on the roadmap. My goal is for SemanticsAV to become the standard, foundational malware scanner for the entire Linux ecosystem, integrated into other great open-source security tools.
But here's the honest truth: I'm an engine developer, not an open-source maintainer. I've spent years obsessed with the core tech, but I'm a novice at building a community. I'm sure the integration experience has rough edges, the CLI could be better, and the documentation has holes.
This is where I need your help. I'm looking for your brutal, honest feedback. Tell me what's broken, what's confusing, and what's missing. I'm here to learn.
Thank you for your time.
Website: https://www.semanticsav.ai/
GitHub: https://github.com/metaforensics-ai/semantics-av-cli

value: Show HN: An AI-native, offline malware scanner for Linux (it's free)

author: mf-skjung


value: denizhdzh

value:
I’ve been building an embeddable AI agent that turns any website into an interactive, context-aware experience.
Unlike typical FAQ bots or generic chat assistants, this one doesn’t just read your PDFs or docs, it also learns from how visitors interact with your site and adapts its responses, recommendations, or offers accordingly.
Technically:
 • Runs fully client-side (no external API calls or backend dependencies)
 • Uses RAG pipelines to reference your own PDFs, documentation, or content base
 • Employs local embeddings to personalize context and answers per visitor session
 • Supports custom styling and can be embedded anywhere on the page
Early results (from SaaS testers):
 • +25–30% increase in trial signups
 • ~20% drop in support tickets
 • Self-serve setup in under 2 minutes
I’d love technical feedback, especially around how it handles embeddings, on-site personalization logic, or UX flow. Happy to share implementation details or discuss architecture trade-offs.

value: Show HN: I built an conversational agent with RAG and Vector Search

author: denizhdzh


value: Show HN: Modern and Clean Httpfs Implementation


value: Show HN: I Gave Kilroy a Body

title: Show HN: I Gave Kilroy a Body


value: DaSettingsPNGN

value:
There are 150 million flagship phones in the world.
They are used for doom scrolling and social media.
They have the computational power of a laptop, and sit unused. That is a waste.
What is stopping us? Heat. I aim to solve that.
I have gotten my code's thermal prediction accuracy to a remarkable level, and was able to launch and sustain an animation rendering Discord bot with real time physics simulations and heavy cache operations and computational backend. My launcher successfully deferred operations before reaching throttle temperature, predicted thermal events before they happened, and during a stress test where I launched my bot quickly to overheat my phone, my launcher shut down my bot before it reached danger level temperature.
UPDATE (Nov 5, 2025):
Performance Numbers (1 hour production test on Discord bot serving 645+ members):
============================================================
PREDICTION ACCURACY
============================================================
Total predictions: 21372
MAE:  1.82°C
RMSE: 3.41°C
Bias: -0.38°C
Within ±1°C: 57.0%
Within ±2°C: 74.6%
Per-zone MAE:
  BATTERY     : 1.68°C (3562 predictions)
  CHASSIS     : 1.77°C (3562 predictions)
  CPU_BIG     : 1.82°C (3562 predictions)
  CPU_LITTLE  : 2.11°C (3562 predictions)
  GPU         : 1.82°C (3562 predictions)
  MODEM       : 1.71°C (3562 predictions)
============================================================
I don't know about everyone else, but I didn't want to pay for a server, and didn't want to host one on my computer. I have a flagship phone; an S25+ with Snapdragon 8 and 12 GB RAM. It's ridiculous. I wanted to run intense computational coding on my phone, and didn't have a solution to keep my phone from overheating. So. I built one. This is non-rooted using sys-reads and Termux (found on Google Play) and Termux API (found on F-Droid), so you can keep your warranty.
Just for ease, the repo is also posted up here.
https://github.com/DaSettingsPNGN/S25_THERMAL-
What my project does: Monitors core temperatures using sys reads and Termux API. It models thermal activity using Newton's Law of Cooling to predict thermal events before they happen and prevent Samsung's aggressive performance throttling at 42° C.
Target audience: Developers who want to run an intensive server on an S25+ without rooting or melting their phone.
Comparison: I haven't seen other predictive thermal modeling used on a phone before. The hardware is concrete and physics can be very good at modeling phone behavior in relation to workload patterns. Samsung itself uses a reactive and throttling system rather than predicting thermal events. Heat is continuous and temperature isn't an isolated event.
I didn't want to pay for a server, and I was also interested in the idea of mobile computing. As my workload increased, I noticed my phone would have temperature problems and performance would degrade quickly. I studied physics and realized that the cores in my phone and the hardware components were perfect candidates for modeling with physics. By using a "thermal bank" where you know how much heat is going to be generated by various workloads through machine learning, you can predict thermal events before they happen and defer operations so that the 42° C thermal throttle limit is never reached. At this limit, Samsung aggressively throttles performance by about 50%, which can cause performance problems, which can generate more heat, and the spiral can get out of hand quickly.
My solution is simple: never reach 42° C
https://github.com/DaSettingsPNGN/S25_THERMAL-
Please take a look and give me feedback.
Thank you!

value: Show HN: Hosting a Production, Computationally Intensive, Mobile Bot

author: DaSettingsPNGN


value: blaesus

value:
While building an LLM-based application, I got frustrated with OpenAI / Claude / LangSmith Agent SDK with their numerous and ambiguous new concepts (agents / tools / skills / guardrail etc.).
So instead I built this little library which helps myself to model LLM-based behaviours with good old functions, branches, and loops.
Currently this only works for TypeScript but I intend to expand to at least Rust and Python which I also use.

value: Show HN: Llamada – minimalist toolkit to define functions with prompts

author: blaesus


value: NabilChiheb

value: Nothing fancy, just a small side project I hacked together when I needed a break from “serious” work. No ads, no monetization, just clicking, upgrading, and watching numbers climb.

value: Show HN: I got bored and built an idle clicker game

author: NabilChiheb


value: Show HN: Chess960v2–over 70 rounds played,some starting positions are undefeated


value: marclelamy

value:
On IOS/MacOS all apps have this share button that open the same sheet where we can share with more apps. I always wanted something that can take any shared item from anywhere and organized it nicely.
Idk how to do mobile development but I have a small AI app so I made an iOS shortcut, and added the Smart Notes as small feature on the app.
How it works:
- Share anything from any app and click the iOS shortcut
- The iOS shortcut sends the content to my backend (with a voice/written note if you want to add a detail about it)
- Depending on the content it gets downloaded/transcribed
- An LLM summarizes and categorizes it
- All the "Smart Notes" get added to a feed UI like on social media
In the feed UI you can see all the Smart Notes that you created, archive them, mark them as favorite, etc...
One thing I use it a lot for is on the lock screen where I can record myself talking and send the recording which will be converted into a written note (you can start it like any iOS shortcut, not always need to share something). I use it for ideas, reminder, todo, etc... It's very practical as I don't have to unlock my phone all the time and can talk for a long time without it breaking. I wish siri would have been able to do this at this point...
It's part of my chatbot and as I give 500 credits for free per month to everyone with an account, you're unlikely to ever pay for it.
I'm planning to add more to it:
- Function tool to my chatbot so you can ask "what was this article about X I saved Y months ago" and have it retrieved super easily
- Browsers extension to save links from there with one button
- For users with no more credits, use a cheaper LLM for unlimited and real free usage
You can try it as https://www.tryblend.ai/smart-notes, I would love some feedback!
Here's a demo: https://oh28wvg0kw.ufs.sh/f/Uq9yFdNAkVnxz3OC9tbWPiYA3Mnrjz7d...

value: Show HN: Smart notes – never loose any bookmark, link or (voice) note again

author: marclelamy


value: meysamazad

value: Show HN: DMARC report parser as a single Go binary (SQLite, no Elasticsearch)

author: meysamazad


value: yezholov

value: Show HN: Korrero – A Headless CMS for in-app notifications to free up dev time

author: yezholov


value: resonaX

value:
I’ve been working on resonaX
 — an experiment to see if we can simulate real B2B customers using AI.
The idea: instead of sending surveys or running A/B tests, what if marketers could ask questions directly to an AI twin of their ideal customer — built from real data like LinkedIn profiles, CRM notes, and behavioral insights?
Each twin captures that customer’s role, pain points, buying triggers, and communication style.
You can then ask:
“Would this headline make sense to you?”
“Why would you hesitate to book a demo?”
“What would make this offer more relevant?”
Under the hood:
LLMs + embedding models fine-tuned on buyer language
Real-world inputs (LinkedIn data, optional CSV uploads)
Lightweight feedback layer to validate responses
70+ beta testers are using it to test messaging and GTM ideas before launch.
Would love feedback from HN:
How might you improve the data ingestion layer?
How can I simulate a focus group?
How can i combine data to create a digital twin of a post like VP of Marketing (broad as some users are demanding not testing with just one profile but a combination of atleast 10)?
Any ideas to make the twin modeling more reliable over time?
Free beta: https://resonax.ai

value: Show HN: I built AI twins from LinkedIn and CRM data to simulate real B2B buyers

author: resonaX


value: aldw

value:
We just released an MCP server that lets Claude (or any MCP client) pull real-time and historical financial data: equities, options chains, crypto, FX, commodities, fundamentals, economic indicators, and 50+ technical signals.
You can ask things like:
“Plot NVDA’s RSI vs AMD’s over the past year.”
“Show the yield curve shift since 2020.”
“What are Apple’s recent earnings surprise trends?
“Make a 3-statement model for ORCL.”
Claude runs the requests, does the math, and returns the data or generates charts/models all inside the chat.
Setup takes about a minute. You’ll need Claude Pro ($20/mo) and a free Alpha Vantage API key (real-time data requires paid).
Quickstart:
https://mcp.alphavantage.co
We also just launched on Product Hunt today:
https://www.producthunt.com/products/alpha-vantage?utm_sourc...
Would love feedback on use-cases, setup flow, or ideas for next integrations.

value: Show HN: Alpha Vantage MCP – Enable your LLM tools with real-time market data

author: aldw


value:
Hello HN! I wanted to share my free, *native*, MacOS app that uses Wifi scanning to automatically keep track if you're in the office or not! It let's you keep track of your RTO requirements to make sure you don't get in trouble :)
If people really like it I can make an iOS version and an Android version and a Windows version and a Linux version.
After RTO, we all started using spreadsheets to track our time, but I hated having to remember to go into that spreadsheet every day and mark when I was in or not. So, I decided to waste months learning Swift UI to make this app instead! Please share your RTO stories below if you need some catharsis :)
It's my first time making a "real" app. I'm by day a Java backend engineer.
https://intheofficetracker.com

value: Show HN: In the Office Tracker

title: Show HN: In the Office Tracker


value: chrka

value: This post about strange attractors isn't as cool as this recent one: https://news.ycombinator.com/item?id=45777810. My visualization runs with my programming language, which is interpreted by WASM code and uses JS and Canvas – without WebGL.

value: Show HN: Strange Attractors – Visualized with Easylang

author: chrka


value: atrettel

value:
Hi, I'm Andrew Trettel.  I'm a scientist and researcher.  I wrote Wosp to help me search local documents using Boolean and proximity operators.
Wosp is a command-line program that performs full-text search on text documents. Wosp stands for word-oriented search and print. It is designed for advanced searchers. It works differently than line-oriented search tools like grep, so it can search for matches spanning multiple lines. Wosp supports an expressive query language that contains both Boolean and proximity operators. It also supports nested queries, truncation, wildcard characters, and fuzzy searching.
The linked GitHub repository contains all of the code to try out the program.  I also wrote a blog post (https://www.andrewtrettel.com/blog/wosp/) that discusses my motivations for creating Wosp in more detail, along with some additional technical discussion and diagrams.
If you give Wosp a try, I'd appreciate any comments or feedback you have about the experience.

value: Show HN: Wosp – advanced full-text search on the command line

author: atrettel


value:
Hey everyone,
For the past year, my team and I have been building PACR (pronounced pacer), an all-in-one academic ecosystem and professional social network designed specifically for academicians.
We are a team driven by a shared feeling that the world of academia lacks a true sense of community. Researchers often work in silos, and in a time where the future of science and research feels increasingly uncertain, we wanted to build a space where academics can feel welcome, connected, and supported.
PACR combines tools to share research, discover papers, connect with others, and discuss ideas, all in one place. We are planning to launch in mid-November, but for now, we have opened up a waitlist for early users.
I am completely new to Hacker News, but I would love to hear your thoughts and feedback about what we are building
Hope you guys have a great day!

value: Show HN: PACR – all in one academic ecosystem and professional social network


value: jaimefjorge

value:
Hi HN.
We launched a free AI Coding Risk Assessment tool to help engineering teams and businesses benchmark the security and compliance posture of their AI coding workflows and policies against peers in the industry.
This anonymous 24-question survey delivers:
- A 0–100 risk score that measures your AI coding security posture
- A live benchmark that compares your AI-assisted development practices with peers
- A research-based checklist that identifies improvement areas
We're seeing more and more clients signal their concerns about the sudden increase of source code written by AI coding agents that nobody’s fully watching or even knows how to oversee. That’s why we created this open benchmarking tool.
We hope this will help companies identify where they stand, compare themselves to the market, and take concrete, actionable steps to leverage AI at scale.
Thanks for reading, we are keen to hear your thoughts!
Link: https://ai-risk.codacy.com/

value: Show HN: Benchmark your team's AI coding security posture

author: jaimefjorge


value: qqxufo

value:
I kept needing a quick, non-cringey opener for meetings/classes and got tired of scrolling listicles. So I made a small site that does two things:
A concise library of icebreaker activities (group size/time/steps; usable at a glance).
A random icebreaker question tool aiming to be safe and broadly workable.
I’d appreciate blunt feedback:
Which questions feel off or awkward?
What obvious activities are missing?
Is the structure/findability OK? Quick fixes you’d make first?
Generator: https://icebreaker-games.org/random-icebreaker-questions

value: Show HN: Icebreaker Games tiny library of icebreakers+random question generator

author: qqxufo


value:
Hey everyone,
I built Vance, an AI SuperConnector that makes warm introductions between founders and investors (and eventually anyone who needs the right connection).
You just tell Vance what you’re looking for - e.g. “I’m raising for my seed round” or “Looking for a co-founder in AI” and he finds the right person from your extended network to introduce you to.
Right now, we’re experimenting with curated networks like IITs, IIMs, and founder communities to help Vance build context and trust.
I’d love feedback from this community -
1. Is this something you’d use?
2. How do you think about privacy/trust in AI led intros?
3. Any thoughts on building strong network density early on?
Would really appreciate any suggestions or brutally honest feedback
Here’s the link if you want to try it: https://vance.so

value: Show HN: I built an AI SuperConnector for founders and VCs


value: stavros

value: Show HN: I was in a boring meeting so I made an encyclopedia

author: stavros


value:
I had a hard time figuring out CAD software like Fusion, OnShape, etc., and decided to go about making my own CAD modeling software that I can "program" my models similar to how I think about them in my head.
I used Cursor to write like 95+% of this, giving it my YAML examples and making it implement the actual code to make those work.
Currently 100% self-hosted, and it is just a static HTML/CSS/JS, so it might just work without running npm at all.
Very few features working currently, basically just modeling a few primitive solids, and boolean operations.

value: Show HN: JermCAD – A YAML-powered, vibe-coded, browser-based CAD software


value: Show HN: Send voice recordings in emails from Gmail and Outlook – Discount Code


value: knid

value:
I noticed that most e-commerce businesses send countless marketing emails that never get opened.
Yet a single push notification can drive instant engagement — it’s direct, real-time, and personal.
The problem? Building a mobile app with push notifications is still expensive, slow, and full of App Store hurdles.
That’s why I built Wemob — a platform that converts any website into a real iOS & Android app instantly with AI, complete with push notifications and automatic store publishing.

value: Show HN: Wemob – Turn any website into a mobile app instantly with AI

author: knid


value: Show HN: Why We're Building Creativity and Game Dev Clubs for Kids


value: jamespetercook

value:
Answer the question "Before I die, I want to..." and post it to the wall.
I built this as part of a journaling app I’m working on as a side project.
Personally I find life goals fascinating - they're the things we think will make us feel the happiest and the most fulfilled, yet often people think they won't achieve them.
I have tried to make it feel atmospheric with the goal of making you stop and think about your own life for a second.

value: Show HN: A living wall of life goals and deathbed regrets

author: jamespetercook


value: moonlightdavid

value:
Hi HN,
I'm building VerifiedProxy - an identity and authorization layer for AI agents.
The problem: As AI agents become autonomous and start transacting on platforms (booking services, making purchases, executing contracts), there's no standard way to verify the agent is actually authorized to act on behalf of a user or business.
Right now platforms either:
- Trust agents blindly (high fraud risk)
- Block agents entirely (miss the opportunity)
- Build custom auth flows (expensive, inconsistent)
VerifiedProxy provides:
- Identity verification for users/businesses (one-time KYC)
- Agent registration (link your AI agents to your verified identity)
- Verification API for platforms (check if agent is authorized before allowing action)
- Optional human-in-loop approval flows (user confirms before agent acts)
It's like OAuth, but for AI agents acting as your legal proxy.
I'm looking for feedback from anyone building platforms or working with autonomous agents. Also interested in early integration partners.
Live at: https://verifiedproxy.com
Happy to answer questions!

value: Show HN: VerifiedProxy – Identity verification for AI agents

author: moonlightdavid


value: Show HN: I built a Quantum superposition word game


value: caioricciuti

value:
Built a terminal dashboard for my M2 Mac because I wanted something better than jumping between Activity Monitor, terminal commands, and random cleanup scripts.
What it does:
Real-time charts for CPU, memory, disk...
Quick actions menu - one key to flush DNS, fix WiFi, kill processes...
Clean up all the dev cache garbage in one place (npm, Homebrew, Xcode, Go, Yarn)
System insights with performance scoring
Basically everything I was doing manually or with different tools, now in one TUI.
Written in Go, GPL-3.0.
https://github.com/caioricciuti/dev-cockpit
Install:
curl -fsSL https://raw.githubusercontent.com/caioricciuti/dev-cockpit/m... | bash
Would appreciate feedback on the UI and what other quick actions or monitoring would be useful.

value: Show HN: Dev Cockpit (OSS) – TUI System Monitor for Apple Silicon

author: caioricciuti


value: sdan

value: Show HN: A model that guesses the location of a photo

author: sdan


value: matt-p

value: I built this while working on a data center design and management tool to automate parts of the build, buy, and deploy process for new sites. Needed an interactive visual component for rack and network design.

value: Show HN: React Component for Server Racks and Networks

author: matt-p


value: ahmddnr

value: Show HN: I Made a Screen Studio Alternative for Windows and macOS

author: ahmddnr


value: lieret

value:
Current evals test LMs on tasks: "fix this bug," "write a test"
But we code to achieve goals: maximize revenue, cut costs, win users
Meet CodeClash: LMs compete via their codebases across multi-round tournaments to achieve high-level goals.
Because real software dev isn’t about following instructions. It’s about achieving outcomes.
Here's how it works:
Two LMs enter a tournament. Each maintains its own codebase.
Every round:
1. Edit Phase: LMs modify their codebases however they like
2. Competition phase: Codebases battle in an arena.
3. Repeat
The LM that wins the majority of rounds is declared winner.
Arenas can be anything like games, trading sims, cybersec envs. We currently have 6 arenas implemented and support for 8 different programming languages.
This has been one of our biggest projects in terms of scale to date. Over the past few months, we've completed 1.5k tournaments, totalling more than 50,400 agent runs. And you can look at all of these runs right now from your browser (links below!)
You can find the rankings on our website (spoiler: Sonnet 4.5 tops the list), but almost more interesting: Humans are still way ahead! In one of our arena, even the worst solution from the human leaderboard is miles ahead of the best LM!
And we're not surprised: LMs consistently fail to properly adapt to outcomes, hallucinate about reasons for failure, and produce ever messier codebases with every round.
More information:
https://codeclash.ai/
https://arxiv.org/pdf/2511.00839
https://github.com/codeclash-ai/codeclash

value: Show HN: New eval from SWE-bench team evalutes LMs based on goals not tickets

author: lieret


value:
Hi HN!
I built a Chrome extension that removes background noise from video files entirely in the browser. Processing is fully on-device (no uploads) and runs ~10× faster than real time—e.g., a 20-minute clip in ~2 minutes.
It supports common containers/codecs, when possible it preserves the original video stream and container, re-encodes only the cleaned audio, and remuxes the result.
I’d love your feedback on quality, format coverage, and any edge-case files. Hope it’s useful to creators!

value: Show HN: In-Browser AI Background Noise Removal for Video/Audio Files


value: JR-Dev

value:
Hey HN! I'm Jens, solo dev who built Lyraa over the past few weeks.
The idea: I wanted lyrics while working/coding, but existing solutions were either slow or locked to specific platforms.
Technical approach:
- Built in C++ with raylib for performance (entire app is <12MB)
- Uses Windows Media Session API for instant song detection (no audio processing needed)
- Custom rendering library for the UI (gradient compositing, layer masking, FXAA)
Business model journey:
- Started with $4.99/month subscription
- Early feedback: "too expensive + subscription fatigue"
- Pivoted to $19.99 one-time purchase
- 100 song free trial, then lifetime access
Current state:
- Windows only (macOS audio loopback is trickier, but planned using the new CoreAudio API)
- Works with Spotify, YouTube, Apple Music, any app supporting Media Session
- Just launched today, would love feedback
Happy to answer questions about the tech stack, business decisions, or anything else!

value: Show HN: Lyraa – Live lyrics for any music app using Windows Media Session API

author: JR-Dev


value: henoverbuilds

value:
I built this to scratch an itch - tracking how some hypothetical portfolios might've played out across market regimes, with realistic simulation and daily pnl tracking.
Most tools available tend to ignore tax lot, cash drag, flexible strategy input or regime analysis. So I decided to ship my own in Rust (backend, NextJS UI) and worked on it over the last few months.
Having worked in the back office of a hedge fund, I have an understanding of how pnl and performance measures are computed. Honestly, it would've been shorter if I have prioritised better. For now, it supports tactical portfolio (fixed allocation) and planning to support more (flexible strategy and more complicated rules).
Key features:
- Regime Awareness
- Head-to-Head Portfolio Comparison
- FIFO tax lot accounting
- ETF and Crypto support
- Automated daily valuation
Beta, free for now. Feel free to provide feedback:
1. Do you find this useful?
2. Whats missing in this that would make you use this more?
3. Would you pay for a tool like this?
https://www.amibeatingbenchmark.app

value: Show HN: Portfolio Simulation with Regime Awareness

author: henoverbuilds


value: nityasha

value:
Hi HN,
We built Nityasha over the last few months and we're launching a public beta today.
The Problem
We switch between 15+ apps daily: email, calendar, notes, tasks, Slack, browser tabs for research, etc. Each context switch kills productivity. We wanted one conversational interface that just handles everything.
What We Have
A single AI assistant that manages:
Email & messages
Calendar & scheduling
Tasks & reminders
Notes & knowledge capture
Web research (real-time)
Coding help
Shopping & research
One conversation replaces dozens of app interactions.
Why It's Different
Most AI assistants are just chatbots. Ours integrates directly with your actual tools (Gmail, Google Calendar, etc.) and takes real actions. You don't describe what you want—it does it.
We're In Public Beta
Starting today at https://ai.nityasha.com/. Free. We'd love feedback on what's actually useful versus what's bloat.

value: Show HN: Nityasha – We Built an AI App That Replaces 10 Apps

author: nityasha


value: hellerve

value:
Hey y’all!
About 7 years ago, I had this idea to write a JIT with an autogenerated backend for x86 based on the ISA specs. I sketched something out and then just kinda let it sit. I picked it up again a few weeks ago and made a complete-ish backend for both x86 and ARM64. It has no dependencies, the backends are completely autogenerated (by horrible, horrible JS scripts), and I built a small abstraciton layer for things like functions prologues etc.
It’s super duper early and will probably break on your machine, but it’s good enough to compile some cool examples (look at the examples directory: https://github.com/hellerve-pl-experiments/cj/tree/master/ex..., my personal favorite is the minimal language implementation: https://github.com/hellerve-pl-experiments/cj/blob/master/ex...).
It doesn’t have anything except basically a fancy JIT assembler with some helpers as of yet. No register allocator, a lot of ABI details will still have to be figured out manually (though of course feel free to add anything to the abstraction layer that’s generally useful and submit a PR!).
I honestly don’t know where I’m going with this next. I kind of stumbled into the project, and am not sure whether I’ll consider it as “exercise completed” or whether I should pursue it more. Time will tell.
Feedback, questions, and bug reports very welcome—especially on the codegen helpers, additional examples or cool things you come up with, or backend rough edges.
P.S.: I also wrote a small announcement blog post on it that you can find here (https://blog.veitheller.de/cj:_Making_a_minimal,_complete_JI...), but it honestly doesn’t add all that much interesting info that you can’t find in the repo.

value: Show HN: Cj–tiny no-deps JIT in C for x86-64 and ARM64

author: hellerve


value: tentoumushi

value:
As a long time Japanese learner, I've always wanted there to be a simple, free online trainer for learning and grinding Japanese kanji and vocabulary - like Monkeytype in the typing community.
I'm doing this because I grew tired of all the subscriptions and paywalls, which are unfortunately very common in the Japanese learning apps market. That's why I want to make the most fun, user-friendly and customizable platform for learning Japanese currently available, and the first one that is (and will be, forever) completely free, ad-free and open-source - driven not by profit, but made by the community, for the community.
Miraculously, I already managed to find a solid amount of contributors and users for the early alpha stages of the app, and I'm looking to grow and develop the app even further to provide a real, high-quality alternative to all the current paid Japanese learning resources. Which I'm sure we can achieve with your and the open-source community's help!
Why am I doing this? Because weebs deserve to have a free, open-source learning platform too (I'm one of them, don't judge...)
どうもありがとうございます!

value: Show HN: I'm making an Open-source Japanese learning App inspired by Monkeytype

author: tentoumushi


value: anxion

value: Show HN: Rust/WASM Weareone.fm Radio Stream Player with 3D Visualization

author: anxion


value: NabilModelRed

value:
Hi everyone,
We built ModelRed to test AI models and apps for security issues. Ran 4,182 attack probes against 9 leading models to see what would break.
Leaderboard: https://modelred.ai (no signup, just check it out)
Claude scored 9.5/10 but still failed on medical/financial prompts. Mistral Large scored 3.3/10. The gap between best and worst is huge.
We test for prompt injections, data leaks, jailbreaks, risky tool calls, domain specific hacks, basically everything that goes wrong when your LLM has access to real data and APIs. The platform runs these tests continuously and blocks CI/CD deployments when scores drop.
Works with any provider (OpenAI, Anthropic, AWS, Huggingface endpoints, OpenRouter etc).
Looking for around 20 people/teams shipping AI in production to be early design partners, help us figure out what features actually matter, contribute attack vectors, shape the roadmap.
Weirdest finding: same prompt injection works on 60% of models because everyone copies the same defense patterns.
Happy to answer questions about methodology, specific vulnerabilities, or if you want to be a design partner.

value: Show HN: We tested 9 AI models with 37K+ security tests

author: NabilModelRed